// 基于cmd/internal/obj/ppc64/asm9。去
// 
// 版权所有©1994-1999朗讯科技有限公司。保留所有权利。
// 版权所有©1995-1997 C H Forsyth(forsyth@terzarima.net)
// 部分版权©1997-1999维塔诺瓦有限公司
// 部分版权©2000-2008维塔诺瓦控股有限公司（www.vitanuova.com）
// 部分版权©20042006布鲁斯·埃利斯
// 修订版版权所有©2000-2008朗讯科技有限公司和其他
// 部分版权所有©2009 Go作者。保留所有权利。
// 
// 特此免费授予获得本软件及相关文档文件（以下简称“软件”）副本
// 的任何人在本软件中不受限制地处理
// 的权利，包括但不限于
// 使用、复制、修改、合并、发布、分发、再许可、，和/或出售本软件的
// 副本，并允许提供本软件的人员在以下条件下这样做：
// 
// 上述版权声明和本许可声明应包含在
// 本软件的所有副本或实质部分中。
// 
// 本软件按“原样”提供，无任何明示或暗示的担保，包括但不限于适销性担保、
// 适用于特定用途和非侵权性担保。在任何情况下，
// 作者或版权持有人均不对任何索赔、损害赔偿或其他
// 责任承担责任，无论是合同、侵权或其他诉讼，均由
// 因本软件或与本软件的使用或其他交易有关而产生。

package s390x

import (
	"cmd/internal/obj"
	"cmd/internal/objabi"
	"fmt"
	"log"
	"math"
	"sort"
)

// ctxtz在组装单个函数时保持状态。
// 每个函数都会得到一个新的ctxtz。
// 这允许同时安全地组装多个功能。
type ctxtz struct {
	ctxt       *obj.Link
	newprog    obj.ProgAlloc
	cursym     *obj.LSym
	autosize   int32
	instoffset int64
	pc         int64
}

// 指令布局。
const (
	funcAlign = 16
)

type Optab struct {
	as obj.As // 操作码
	i  uint8  // 处理程序索引
	a1 uint8  // 来自
	a2 uint8  // Reg 
	a3 uint8  // 重新启动[0]
	a4 uint8  // 重新启动[1]
	a5 uint8  // 重新启动[2]
	a6 uint8  // 至
}

var optab = []Optab{
	// 零长度指令
	{i: 0, as: obj.ATEXT, a1: C_ADDR, a6: C_TEXTSIZE},
	{i: 0, as: obj.ATEXT, a1: C_ADDR, a3: C_LCON, a6: C_TEXTSIZE},
	{i: 0, as: obj.APCDATA, a1: C_LCON, a6: C_LCON},
	{i: 0, as: obj.AFUNCDATA, a1: C_SCON, a6: C_ADDR},
	{i: 0, as: obj.ANOP},
	{i: 0, as: obj.ANOP, a1: C_SAUTO},

	// 移动寄存器
	{i: 1, as: AMOVD, a1: C_REG, a6: C_REG},
	{i: 1, as: AMOVB, a1: C_REG, a6: C_REG},
	{i: 1, as: AMOVBZ, a1: C_REG, a6: C_REG},
	{i: 1, as: AMOVW, a1: C_REG, a6: C_REG},
	{i: 1, as: AMOVWZ, a1: C_REG, a6: C_REG},
	{i: 1, as: AFMOVD, a1: C_FREG, a6: C_FREG},
	{i: 1, as: AMOVDBR, a1: C_REG, a6: C_REG},

	// 加载常数
	{i: 26, as: AMOVD, a1: C_LACON, a6: C_REG},
	{i: 26, as: AMOVW, a1: C_LACON, a6: C_REG},
	{i: 26, as: AMOVWZ, a1: C_LACON, a6: C_REG},
	{i: 3, as: AMOVD, a1: C_DCON, a6: C_REG},
	{i: 3, as: AMOVW, a1: C_DCON, a6: C_REG},
	{i: 3, as: AMOVWZ, a1: C_DCON, a6: C_REG},
	{i: 3, as: AMOVB, a1: C_DCON, a6: C_REG},
	{i: 3, as: AMOVBZ, a1: C_DCON, a6: C_REG},

	{i: 72, as: AMOVD, a1: C_SCON, a6: C_LAUTO},
	{i: 72, as: AMOVD, a1: C_ADDCON, a6: C_LAUTO},
	{i: 72, as: AMOVW, a1: C_SCON, a6: C_LAUTO},
	{i: 72, as: AMOVW, a1: C_ADDCON, a6: C_LAUTO},
	{i: 72, as: AMOVWZ, a1: C_SCON, a6: C_LAUTO},
	{i: 72, as: AMOVWZ, a1: C_ADDCON, a6: C_LAUTO},
	{i: 72, as: AMOVB, a1: C_SCON, a6: C_LAUTO},
	{i: 72, as: AMOVB, a1: C_ADDCON, a6: C_LAUTO},
	{i: 72, as: AMOVBZ, a1: C_SCON, a6: C_LAUTO},
	{i: 72, as: AMOVBZ, a1: C_ADDCON, a6: C_LAUTO},
	{i: 72, as: AMOVD, a1: C_SCON, a6: C_LOREG},
	{i: 72, as: AMOVD, a1: C_ADDCON, a6: C_LOREG},
	{i: 72, as: AMOVW, a1: C_SCON, a6: C_LOREG},
	{i: 72, as: AMOVW, a1: C_ADDCON, a6: C_LOREG},
	{i: 72, as: AMOVWZ, a1: C_SCON, a6: C_LOREG},
	{i: 72, as: AMOVWZ, a1: C_ADDCON, a6: C_LOREG},
	{i: 72, as: AMOVB, a1: C_SCON, a6: C_LOREG},
	{i: 72, as: AMOVB, a1: C_ADDCON, a6: C_LOREG},
	{i: 72, as: AMOVBZ, a1: C_SCON, a6: C_LOREG},
	{i: 72, as: AMOVBZ, a1: C_ADDCON, a6: C_LOREG},

	{i: 35, as: AMOVD, a1: C_REG, a6: C_LAUTO},
	{i: 35, as: AMOVW, a1: C_REG, a6: C_LAUTO},
	{i: 35, as: AMOVWZ, a1: C_REG, a6: C_LAUTO},
	{i: 35, as: AMOVBZ, a1: C_REG, a6: C_LAUTO},
	{i: 35, as: AMOVB, a1: C_REG, a6: C_LAUTO},
	{i: 35, as: AMOVDBR, a1: C_REG, a6: C_LAUTO},
	{i: 35, as: AMOVHBR, a1: C_REG, a6: C_LAUTO},
	{i: 35, as: AMOVD, a1: C_REG, a6: C_LOREG},
	{i: 35, as: AMOVW, a1: C_REG, a6: C_LOREG},
	{i: 35, as: AMOVWZ, a1: C_REG, a6: C_LOREG},
	{i: 35, as: AMOVBZ, a1: C_REG, a6: C_LOREG},
	{i: 35, as: AMOVB, a1: C_REG, a6: C_LOREG},
	{i: 35, as: AMOVDBR, a1: C_REG, a6: C_LOREG},
	{i: 35, as: AMOVHBR, a1: C_REG, a6: C_LOREG},
	{i: 74, as: AMOVD, a1: C_REG, a6: C_ADDR},
	{i: 74, as: AMOVW, a1: C_REG, a6: C_ADDR},
	{i: 74, as: AMOVWZ, a1: C_REG, a6: C_ADDR},
	{i: 74, as: AMOVBZ, a1: C_REG, a6: C_ADDR},
	{i: 74, as: AMOVB, a1: C_REG, a6: C_ADDR},

	// 加载
	{i: 36, as: AMOVD, a1: C_LAUTO, a6: C_REG},
	{i: 36, as: AMOVW, a1: C_LAUTO, a6: C_REG},
	{i: 36, as: AMOVWZ, a1: C_LAUTO, a6: C_REG},
	{i: 36, as: AMOVBZ, a1: C_LAUTO, a6: C_REG},
	{i: 36, as: AMOVB, a1: C_LAUTO, a6: C_REG},
	{i: 36, as: AMOVDBR, a1: C_LAUTO, a6: C_REG},
	{i: 36, as: AMOVHBR, a1: C_LAUTO, a6: C_REG},
	{i: 36, as: AMOVD, a1: C_LOREG, a6: C_REG},
	{i: 36, as: AMOVW, a1: C_LOREG, a6: C_REG},
	{i: 36, as: AMOVWZ, a1: C_LOREG, a6: C_REG},
	{i: 36, as: AMOVBZ, a1: C_LOREG, a6: C_REG},
	{i: 36, as: AMOVB, a1: C_LOREG, a6: C_REG},
	{i: 36, as: AMOVDBR, a1: C_LOREG, a6: C_REG},
	{i: 36, as: AMOVHBR, a1: C_LOREG, a6: C_REG},
	{i: 75, as: AMOVD, a1: C_ADDR, a6: C_REG},
	{i: 75, as: AMOVW, a1: C_ADDR, a6: C_REG},
	{i: 75, as: AMOVWZ, a1: C_ADDR, a6: C_REG},
	{i: 75, as: AMOVBZ, a1: C_ADDR, a6: C_REG},
	{i: 75, as: AMOVB, a1: C_ADDR, a6: C_REG},

	// 联锁加载和操作
	{i: 99, as: ALAAG, a1: C_REG, a2: C_REG, a6: C_LOREG},

	// 整数算法
	{i: 2, as: AADD, a1: C_REG, a2: C_REG, a6: C_REG},
	{i: 2, as: AADD, a1: C_REG, a6: C_REG},
	{i: 22, as: AADD, a1: C_LCON, a2: C_REG, a6: C_REG},
	{i: 22, as: AADD, a1: C_LCON, a6: C_REG},
	{i: 12, as: AADD, a1: C_LOREG, a6: C_REG},
	{i: 12, as: AADD, a1: C_LAUTO, a6: C_REG},
	{i: 21, as: ASUB, a1: C_LCON, a2: C_REG, a6: C_REG},
	{i: 21, as: ASUB, a1: C_LCON, a6: C_REG},
	{i: 12, as: ASUB, a1: C_LOREG, a6: C_REG},
	{i: 12, as: ASUB, a1: C_LAUTO, a6: C_REG},
	{i: 4, as: AMULHD, a1: C_REG, a6: C_REG},
	{i: 4, as: AMULHD, a1: C_REG, a2: C_REG, a6: C_REG},
	{i: 62, as: AMLGR, a1: C_REG, a6: C_REG},
	{i: 2, as: ADIVW, a1: C_REG, a2: C_REG, a6: C_REG},
	{i: 2, as: ADIVW, a1: C_REG, a6: C_REG},
	{i: 10, as: ASUB, a1: C_REG, a2: C_REG, a6: C_REG},
	{i: 10, as: ASUB, a1: C_REG, a6: C_REG},
	{i: 47, as: ANEG, a1: C_REG, a6: C_REG},
	{i: 47, as: ANEG, a6: C_REG},

	// 整数逻辑
	{i: 6, as: AAND, a1: C_REG, a2: C_REG, a6: C_REG},
	{i: 6, as: AAND, a1: C_REG, a6: C_REG},
	{i: 23, as: AAND, a1: C_LCON, a6: C_REG},
	{i: 12, as: AAND, a1: C_LOREG, a6: C_REG},
	{i: 12, as: AAND, a1: C_LAUTO, a6: C_REG},
	{i: 6, as: AANDW, a1: C_REG, a2: C_REG, a6: C_REG},
	{i: 6, as: AANDW, a1: C_REG, a6: C_REG},
	{i: 24, as: AANDW, a1: C_LCON, a6: C_REG},
	{i: 12, as: AANDW, a1: C_LOREG, a6: C_REG},
	{i: 12, as: AANDW, a1: C_LAUTO, a6: C_REG},
	{i: 7, as: ASLD, a1: C_REG, a6: C_REG},
	{i: 7, as: ASLD, a1: C_REG, a2: C_REG, a6: C_REG},
	{i: 7, as: ASLD, a1: C_SCON, a2: C_REG, a6: C_REG},
	{i: 7, as: ASLD, a1: C_SCON, a6: C_REG},
	{i: 13, as: ARNSBG, a1: C_SCON, a3: C_SCON, a4: C_SCON, a5: C_REG, a6: C_REG},

	// 比较和交换
	{i: 79, as: ACSG, a1: C_REG, a2: C_REG, a6: C_SOREG},

	// 浮点
	{i: 32, as: AFADD, a1: C_FREG, a6: C_FREG},
	{i: 33, as: AFABS, a1: C_FREG, a6: C_FREG},
	{i: 33, as: AFABS, a6: C_FREG},
	{i: 34, as: AFMADD, a1: C_FREG, a2: C_FREG, a6: C_FREG},
	{i: 32, as: AFMUL, a1: C_FREG, a6: C_FREG},
	{i: 36, as: AFMOVD, a1: C_LAUTO, a6: C_FREG},
	{i: 36, as: AFMOVD, a1: C_LOREG, a6: C_FREG},
	{i: 75, as: AFMOVD, a1: C_ADDR, a6: C_FREG},
	{i: 35, as: AFMOVD, a1: C_FREG, a6: C_LAUTO},
	{i: 35, as: AFMOVD, a1: C_FREG, a6: C_LOREG},
	{i: 74, as: AFMOVD, a1: C_FREG, a6: C_ADDR},
	{i: 67, as: AFMOVD, a1: C_ZCON, a6: C_FREG},
	{i: 81, as: ALDGR, a1: C_REG, a6: C_FREG},
	{i: 81, as: ALGDR, a1: C_FREG, a6: C_REG},
	{i: 82, as: ACEFBRA, a1: C_REG, a6: C_FREG},
	{i: 83, as: ACFEBRA, a1: C_FREG, a6: C_REG},
	{i: 48, as: AFIEBR, a1: C_SCON, a2: C_FREG, a6: C_FREG},
	{i: 49, as: ACPSDR, a1: C_FREG, a2: C_FREG, a6: C_FREG},
	{i: 50, as: ALTDBR, a1: C_FREG, a6: C_FREG},
	{i: 51, as: ATCDB, a1: C_FREG, a6: C_SCON},

	// 加载符号地址（加偏移量）
	{i: 19, as: AMOVD, a1: C_SYMADDR, a6: C_REG},
	{i: 93, as: AMOVD, a1: C_GOTADDR, a6: C_REG},
	{i: 94, as: AMOVD, a1: C_TLS_LE, a6: C_REG},
	{i: 95, as: AMOVD, a1: C_TLS_IE, a6: C_REG},

	// 系统调用
	{i: 5, as: ASYSCALL},
	{i: 77, as: ASYSCALL, a1: C_SCON},

	// 分支
	{i: 16, as: ABEQ, a6: C_SBRA},
	{i: 16, as: ABRC, a1: C_SCON, a6: C_SBRA},
	{i: 11, as: ABR, a6: C_LBRA},
	{i: 16, as: ABC, a1: C_SCON, a2: C_REG, a6: C_LBRA},
	{i: 18, as: ABR, a6: C_REG},
	{i: 18, as: ABR, a1: C_REG, a6: C_REG},
	{i: 15, as: ABR, a6: C_ZOREG},
	{i: 15, as: ABC, a6: C_ZOREG},

	// 比较和分支
	{i: 89, as: ACGRJ, a1: C_SCON, a2: C_REG, a3: C_REG, a6: C_SBRA},
	{i: 89, as: ACMPBEQ, a1: C_REG, a2: C_REG, a6: C_SBRA},
	{i: 89, as: ACLGRJ, a1: C_SCON, a2: C_REG, a3: C_REG, a6: C_SBRA},
	{i: 89, as: ACMPUBEQ, a1: C_REG, a2: C_REG, a6: C_SBRA},
	{i: 90, as: ACGIJ, a1: C_SCON, a2: C_REG, a3: C_ADDCON, a6: C_SBRA},
	{i: 90, as: ACGIJ, a1: C_SCON, a2: C_REG, a3: C_SCON, a6: C_SBRA},
	{i: 90, as: ACMPBEQ, a1: C_REG, a3: C_ADDCON, a6: C_SBRA},
	{i: 90, as: ACMPBEQ, a1: C_REG, a3: C_SCON, a6: C_SBRA},
	{i: 90, as: ACLGIJ, a1: C_SCON, a2: C_REG, a3: C_ADDCON, a6: C_SBRA},
	{i: 90, as: ACMPUBEQ, a1: C_REG, a3: C_ANDCON, a6: C_SBRA},

	// 计数上的分支
	{i: 41, as: ABRCT, a1: C_REG, a6: C_SBRA},
	{i: 41, as: ABRCTG, a1: C_REG, a6: C_SBRA},

	// 条件下移动
	{i: 17, as: AMOVDEQ, a1: C_REG, a6: C_REG},

	// 条件下加载
	{i: 25, as: ALOCGR, a1: C_SCON, a2: C_REG, a6: C_REG},

	// 查找最左边的一个
	{i: 8, as: AFLOGR, a1: C_REG, a6: C_REG},

	// 人口计数
	{i: 9, as: APOPCNT, a1: C_REG, a6: C_REG},

	// 比较
	{i: 70, as: ACMP, a1: C_REG, a6: C_REG},
	{i: 71, as: ACMP, a1: C_REG, a6: C_LCON},
	{i: 70, as: ACMPU, a1: C_REG, a6: C_REG},
	{i: 71, as: ACMPU, a1: C_REG, a6: C_LCON},
	{i: 70, as: AFCMPO, a1: C_FREG, a6: C_FREG},
	{i: 70, as: AFCMPO, a1: C_FREG, a2: C_REG, a6: C_FREG},

	{i: 91, as: ATMHH, a1: C_REG, a6: C_ANDCON},

	// 在掩码下测试
	// 插入程序掩码
	{i: 92, as: AIPM, a1: C_REG},

	// 设置程序掩码
	{i: 76, as: ASPM, a1: C_REG},

	// 32位访问寄存器
	{i: 68, as: AMOVW, a1: C_AREG, a6: C_REG},
	{i: 68, as: AMOVWZ, a1: C_AREG, a6: C_REG},
	{i: 69, as: AMOVW, a1: C_REG, a6: C_AREG},
	{i: 69, as: AMOVWZ, a1: C_REG, a6: C_AREG},

	// 宏
	{i: 96, as: ACLEAR, a1: C_LCON, a6: C_LOREG},
	{i: 96, as: ACLEAR, a1: C_LCON, a6: C_LAUTO},

	// 加载/存储多个
	{i: 97, as: ASTMG, a1: C_REG, a2: C_REG, a6: C_LOREG},
	{i: 97, as: ASTMG, a1: C_REG, a2: C_REG, a6: C_LAUTO},
	{i: 98, as: ALMG, a1: C_LOREG, a2: C_REG, a6: C_REG},
	{i: 98, as: ALMG, a1: C_LAUTO, a2: C_REG, a6: C_REG},

	// 字节
	{i: 40, as: ABYTE, a1: C_SCON},
	{i: 40, as: AWORD, a1: C_LCON},
	{i: 31, as: ADWORD, a1: C_LCON},
	{i: 31, as: ADWORD, a1: C_DCON},

	// 快速同步
	{i: 80, as: ASYNC},

	// 存储时钟
	{i: 88, as: ASTCK, a6: C_SAUTO},
	{i: 88, as: ASTCK, a6: C_SOREG},

	// 存储
	{i: 84, as: AMVC, a1: C_SCON, a3: C_LOREG, a6: C_LOREG},
	{i: 84, as: AMVC, a1: C_SCON, a3: C_LOREG, a6: C_LAUTO},
	{i: 84, as: AMVC, a1: C_SCON, a3: C_LAUTO, a6: C_LAUTO},

	// 地址
	{i: 85, as: ALARL, a1: C_LCON, a6: C_REG},
	{i: 85, as: ALARL, a1: C_SYMADDR, a6: C_REG},
	{i: 86, as: ALA, a1: C_SOREG, a6: C_REG},
	{i: 86, as: ALA, a1: C_SAUTO, a6: C_REG},
	{i: 87, as: AEXRL, a1: C_SYMADDR, a6: C_REG},

	// 未定义（故意非法指令）
	{i: 78, as: obj.AUNDEF},

	// 2字节无操作
	{i: 66, as: ANOPH},


	// VRX存储
	{i: 100, as: AVST, a1: C_VREG, a6: C_SOREG},
	{i: 100, as: AVST, a1: C_VREG, a6: C_SAUTO},
	{i: 100, as: AVSTEG, a1: C_SCON, a2: C_VREG, a6: C_SOREG},
	{i: 100, as: AVSTEG, a1: C_SCON, a2: C_VREG, a6: C_SAUTO},

	// VRX加载
	{i: 101, as: AVL, a1: C_SOREG, a6: C_VREG},
	{i: 101, as: AVL, a1: C_SAUTO, a6: C_VREG},
	{i: 101, as: AVLEG, a1: C_SCON, a3: C_SOREG, a6: C_VREG},
	{i: 101, as: AVLEG, a1: C_SCON, a3: C_SAUTO, a6: C_VREG},

	// VRV分散
	{i: 102, as: AVSCEG, a1: C_SCON, a2: C_VREG, a6: C_SOREG},
	{i: 102, as: AVSCEG, a1: C_SCON, a2: C_VREG, a6: C_SAUTO},

	// VRV聚集
	{i: 103, as: AVGEG, a1: C_SCON, a3: C_SOREG, a6: C_VREG},
	{i: 103, as: AVGEG, a1: C_SCON, a3: C_SAUTO, a6: C_VREG},

	// VRS元素移位/旋转并将gr加载到vr元素
	{i: 104, as: AVESLG, a1: C_SCON, a2: C_VREG, a6: C_VREG},
	{i: 104, as: AVESLG, a1: C_REG, a2: C_VREG, a6: C_VREG},
	{i: 104, as: AVESLG, a1: C_SCON, a6: C_VREG},
	{i: 104, as: AVESLG, a1: C_REG, a6: C_VREG},
	{i: 104, as: AVLGVG, a1: C_SCON, a2: C_VREG, a6: C_REG},
	{i: 104, as: AVLGVG, a1: C_REG, a2: C_VREG, a6: C_REG},
	{i: 104, as: AVLVGG, a1: C_SCON, a2: C_REG, a6: C_VREG},
	{i: 104, as: AVLVGG, a1: C_REG, a2: C_REG, a6: C_VREG},

	// VRS存储多个
	{i: 105, as: AVSTM, a1: C_VREG, a2: C_VREG, a6: C_SOREG},
	{i: 105, as: AVSTM, a1: C_VREG, a2: C_VREG, a6: C_SAUTO},

	// VRS加载多个
	{i: 106, as: AVLM, a1: C_SOREG, a2: C_VREG, a6: C_VREG},
	{i: 106, as: AVLM, a1: C_SAUTO, a2: C_VREG, a6: C_VREG},

	// VRS存储长度
	{i: 107, as: AVSTL, a1: C_REG, a2: C_VREG, a6: C_SOREG},
	{i: 107, as: AVSTL, a1: C_REG, a2: C_VREG, a6: C_SAUTO},

	{i: 108, as: AVLL, a1: C_REG, a3: C_SOREG, a6: C_VREG},
	{i: 108, as: AVLL, a1: C_REG, a3: C_SAUTO, a6: C_VREG},

	{i: 109, as: AVGBM, a1: C_ANDCON, a6: C_VREG},
	{i: 109, as: AVZERO, a6: C_VREG},
	{i: 109, as: AVREPIG, a1: C_ADDCON, a6: C_VREG},
	{i: 109, as: AVREPIG, a1: C_SCON, a6: C_VREG},
	{i: 109, as: AVLEIG, a1: C_SCON, a3: C_ADDCON, a6: C_VREG},
	{i: 109, as: AVLEIG, a1: C_SCON, a3: C_SCON, a6: C_VREG},

	// VRI-b生成掩码
	{i: 110, as: AVGMG, a1: C_SCON, a3: C_SCON, a6: C_VREG},

	// VRI-c复制
	{i: 111, as: AVREPG, a1: C_UCON, a2: C_VREG, a6: C_VREG},

	// VRI-d元素在掩码下旋转和插入，
	// VRI-d fp测试数据类立即
	{i: 112, as: AVERIMG, a1: C_SCON, a2: C_VREG, a3: C_VREG, a6: C_VREG},
	{i: 112, as: AVSLDB, a1: C_SCON, a2: C_VREG, a3: C_VREG, a6: C_VREG},

	{i: 113, as: AVFTCIDB, a1: C_SCON, a2: C_VREG, a6: C_VREG},

	// VRR-a加载寄存器
	{i: 114, as: AVLR, a1: C_VREG, a6: C_VREG},

	// VRR-a比较
	{i: 115, as: AVECG, a1: C_VREG, a6: C_VREG},

	{i: 117, as: AVCEQG, a1: C_VREG, a2: C_VREG, a6: C_VREG},
	{i: 117, as: AVFAEF, a1: C_VREG, a2: C_VREG, a6: C_VREG},
	{i: 117, as: AVPKSG, a1: C_VREG, a2: C_VREG, a6: C_VREG},

	{i: 118, as: AVAQ, a1: C_VREG, a2: C_VREG, a6: C_VREG},
	{i: 118, as: AVAQ, a1: C_VREG, a6: C_VREG},
	{i: 118, as: AVNOT, a1: C_VREG, a6: C_VREG},
	{i: 123, as: AVPDI, a1: C_SCON, a2: C_VREG, a3: C_VREG, a6: C_VREG},

	// VRR-c shifts 
	{i: 119, as: AVERLLVG, a1: C_VREG, a2: C_VREG, a6: C_VREG},
	{i: 119, as: AVERLLVG, a1: C_VREG, a6: C_VREG},

	// VRR-d 
	{i: 120, as: AVACQ, a1: C_VREG, a2: C_VREG, a3: C_VREG, a6: C_VREG},

	// VRR-e 
	{i: 121, as: AVSEL, a1: C_VREG, a2: C_VREG, a3: C_VREG, a6: C_VREG},

	// VRR-f 
	{i: 122, as: AVLVGP, a1: C_REG, a2: C_REG, a6: C_VREG},
}

var oprange [ALAST & obj.AMask][]Optab

var xcmp [C_NCLASS][C_NCLASS]bool

func spanz(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
	if ctxt.Retpoline {
		ctxt.Diag("-spectre=ret not supported on s390x")
		ctxt.Retpoline = false // 不要继续打印
	}

	p := cursym.Func().Text
	if p == nil || p.Link == nil { // 处理外部函数和ELF节符号
		return
	}

	if oprange[AORW&obj.AMask] == nil {
		ctxt.Diag("s390x ops not initialized, call s390x.buildop first")
	}

	c := ctxtz{ctxt: ctxt, newprog: newprog, cursym: cursym, autosize: int32(p.To.Offset)}

	buffer := make([]byte, 0)
	changed := true
	loop := 0
	nrelocs0 := len(c.cursym.R)
	for changed {
		if loop > 100 {
			c.ctxt.Diag("stuck in spanz loop")
			break
		}
		changed = false
		buffer = buffer[:0]
		for i := range c.cursym.R[nrelocs0:] {
			c.cursym.R[nrelocs0+i] = obj.Reloc{}
		}
		c.cursym.R = c.cursym.R[:nrelocs0] // 保留编译器
		for p := c.cursym.Func().Text; p != nil; p = p.Link {
			pc := int64(len(buffer))
			if pc != p.Pc {
				changed = true
			}
			p.Pc = pc
			c.pc = p.Pc
			c.asmout(p, &buffer)
			if pc == int64(len(buffer)) {
				switch p.As {
				case obj.ANOP, obj.AFUNCDATA, obj.APCDATA, obj.ATEXT:
					// ok 
				default:
					c.ctxt.Diag("zero-width instruction\n%v", p)
				}
			}
		}
		loop++
	}

	c.cursym.Size = int64(len(buffer))
	if c.cursym.Size%funcAlign != 0 {
		c.cursym.Size += funcAlign - (c.cursym.Size % funcAlign)
	}
	c.cursym.Grow(c.cursym.Size)
	copy(c.cursym.P, buffer)

	// 标记不可释放的指令序列。
	// 我们在调用注入期间使用REGTMP作为暂存器，所以使用REGTMP的指令序列对
	// 异步抢占是不安全的。
	obj.MarkUnsafePoints(c.ctxt, c.cursym.Func().Text, c.newprog, c.isUnsafePoint, nil)
}

// 返回p是否为不安全点。
func (c *ctxtz) isUnsafePoint(p *obj.Prog) bool {
	if p.From.Reg == REGTMP || p.To.Reg == REGTMP || p.Reg == REGTMP {
		return true
	}
	for _, a := range p.RestArgs {
		if a.Reg == REGTMP {
			return true
		}
	}
	return p.Mark&USETMP != 0
}

func isint32(v int64) bool {
	return int64(int32(v)) == v
}

func isuint32(v uint64) bool {
	return uint64(uint32(v)) == v
}

func (c *ctxtz) aclass(a *obj.Addr) int {
	switch a.Type {
	case obj.TYPE_NONE:
		return C_NONE

	case obj.TYPE_REG:
		if REG_R0 <= a.Reg && a.Reg <= REG_R15 {
			return C_REG
		}
		if REG_F0 <= a.Reg && a.Reg <= REG_F15 {
			return C_FREG
		}
		if REG_AR0 <= a.Reg && a.Reg <= REG_AR15 {
			return C_AREG
		}
		if REG_V0 <= a.Reg && a.Reg <= REG_V31 {
			return C_VREG
		}
		return C_GOK

	case obj.TYPE_MEM:
		switch a.Name {
		case obj.NAME_EXTERN,
			obj.NAME_STATIC:
			if a.Sym == nil {
				// 必须有一个符号
				break
			}
			c.instoffset = a.Offset
			if a.Sym.Type == objabi.STLSBSS {
				if c.ctxt.Flag_shared {
					return C_TLS_IE // 初始exec模型
				}
				return C_TLS_LE // 本地exec模型
			}
			return C_ADDR

		case obj.NAME_GOTREF:
			return C_GOTADDR

		case obj.NAME_AUTO:
			if a.Reg == REGSP {
				// 取消基址寄存器以便更好地打印，因为
				// a。偏移量仍然相对于伪SP。
				a.Reg = obj.REG_NONE
			}
			c.instoffset = int64(c.autosize) + a.Offset
			if c.instoffset >= -BIG && c.instoffset < BIG {
				return C_SAUTO
			}
			return C_LAUTO

		case obj.NAME_PARAM:
			if a.Reg == REGSP {
				// 取消基址寄存器以便更好地打印，因为
				// a。偏移量仍然相对于伪FP。
				a.Reg = obj.REG_NONE
			}
			c.instoffset = int64(c.autosize) + a.Offset + c.ctxt.FixedFrameSize()
			if c.instoffset >= -BIG && c.instoffset < BIG {
				return C_SAUTO
			}
			return C_LAUTO

		case obj.NAME_NONE:
			c.instoffset = a.Offset
			if c.instoffset == 0 {
				return C_ZOREG
			}
			if c.instoffset >= -BIG && c.instoffset < BIG {
				return C_SOREG
			}
			return C_LOREG
		}

		return C_GOK

	case obj.TYPE_TEXTSIZE:
		return C_TEXTSIZE

	case obj.TYPE_FCONST:
		if f64, ok := a.Val.(float64); ok && math.Float64bits(f64) == 0 {
			return C_ZCON
		}
		c.ctxt.Diag("cannot handle the floating point constant %v", a.Val)

	case obj.TYPE_CONST,
		obj.TYPE_ADDR:
		switch a.Name {
		case obj.NAME_NONE:
			c.instoffset = a.Offset
			if a.Reg != 0 {
				if -BIG <= c.instoffset && c.instoffset <= BIG {
					return C_SACON
				}
				if isint32(c.instoffset) {
					return C_LACON
				}
				return C_DACON
			}

		case obj.NAME_EXTERN,
			obj.NAME_STATIC:
			s := a.Sym
			if s == nil {
				return C_GOK
			}
			c.instoffset = a.Offset

			return C_SYMADDR

		case obj.NAME_AUTO:
			if a.Reg == REGSP {
				// 为更好的打印而取消基址寄存器设置，因为
				// a.偏移量仍然相对于伪SP。
				a.Reg = obj.REG_NONE
			}
			c.instoffset = int64(c.autosize) + a.Offset
			if c.instoffset >= -BIG && c.instoffset < BIG {
				return C_SACON
			}
			return C_LACON

		case obj.NAME_PARAM:
			if a.Reg == REGSP {
				// 为更好的打印而取消基址寄存器设置，因为
				// a.偏移量仍然相对于伪FP。
				a.Reg = obj.REG_NONE
			}
			c.instoffset = int64(c.autosize) + a.Offset + c.ctxt.FixedFrameSize()
			if c.instoffset >= -BIG && c.instoffset < BIG {
				return C_SACON
			}
			return C_LACON

		default:
			return C_GOK
		}

		if c.instoffset == 0 {
			return C_ZCON
		}
		if c.instoffset >= 0 {
			if c.instoffset <= 0x7fff {
				return C_SCON
			}
			if c.instoffset <= 0xffff {
				return C_ANDCON
			}
			if c.instoffset&0xffff == 0 && isuint32(uint64(c.instoffset)) { /* && (instoffset & (1<<31)) == 0) */
				return C_UCON
			}
			if isint32(c.instoffset) || isuint32(uint64(c.instoffset)) {
				return C_LCON
			}
			return C_DCON
		}

		if c.instoffset >= -0x8000 {
			return C_ADDCON
		}
		if c.instoffset&0xffff == 0 && isint32(c.instoffset) {
			return C_UCON
		}
		if isint32(c.instoffset) {
			return C_LCON
		}
		return C_DCON

	case obj.TYPE_BRANCH:
		return C_SBRA
	}

	return C_GOK
}

func (c *ctxtz) oplook(p *obj.Prog) *Optab {
	// 返回缓存的optab项（如果可用）。
	if p.Optab != 0 {
		return &optab[p.Optab-1]
	}
	if len(p.RestArgs) > 3 {
		c.ctxt.Diag("too many RestArgs: got %v, maximum is 3\n", len(p.RestArgs))
		return nil
	}

	// 初始化所有参数的类。
	p.From.Class = int8(c.aclass(&p.From) + 1)
	p.To.Class = int8(c.aclass(&p.To) + 1)
	for i := range p.RestArgs {
		p.RestArgs[i].Addr.Class = int8(c.aclass(&p.RestArgs[i].Addr) + 1)
	}

	// 在Optab中镜像参数列表。
	args := [...]int8{
		p.From.Class - 1,
		C_NONE, // p.Reg 
		C_NONE, // p.RestArgs[0]
		C_NONE, // p.RestArgs[1]
		C_NONE, // p.RestArgs[2]
		p.To.Class - 1,
	}
	// p.Reg.填写参数类。
	switch {
	case REG_R0 <= p.Reg && p.Reg <= REG_R15:
		args[1] = C_REG
	case REG_V0 <= p.Reg && p.Reg <= REG_V31:
		args[1] = C_VREG
	case REG_F0 <= p.Reg && p.Reg <= REG_F15:
		args[1] = C_FREG
	case REG_AR0 <= p.Reg && p.Reg <= REG_AR15:
		args[1] = C_AREG
	}
	// 为p.RestArgs填写参数类。
	for i, a := range p.RestArgs {
		args[2+i] = a.Class - 1
	}

	// 在optab中查找op。
	ops := oprange[p.As&obj.AMask]
	cmp := [len(args)]*[C_NCLASS]bool{}
	for i := range cmp {
		cmp[i] = &xcmp[args[i]]
	}
	for i := range ops {
		op := &ops[i]
		if cmp[0][op.a1] && cmp[1][op.a2] &&
			cmp[2][op.a3] && cmp[3][op.a4] &&
			cmp[4][op.a5] && cmp[5][op.a6] {
			p.Optab = uint16(cap(optab) - cap(ops) + i + 1)
			return op
		}
	}

	// 找不到病例；中止
	s := ""
	for _, a := range args {
		s += fmt.Sprintf(" %v", DRconv(int(a)))
	}
	c.ctxt.Diag("illegal combination %v%v\n", p.As, s)
	c.ctxt.Diag("prog: %v\n", p)
	return nil
}

func cmp(a int, b int) bool {
	if a == b {
		return true
	}
	switch a {
	case C_DCON:
		if b == C_LCON {
			return true
		}
		fallthrough
	case C_LCON:
		if b == C_ZCON || b == C_SCON || b == C_UCON || b == C_ADDCON || b == C_ANDCON {
			return true
		}

	case C_ADDCON:
		if b == C_ZCON || b == C_SCON {
			return true
		}

	case C_ANDCON:
		if b == C_ZCON || b == C_SCON {
			return true
		}

	case C_UCON:
		if b == C_ZCON || b == C_SCON {
			return true
		}

	case C_SCON:
		if b == C_ZCON {
			return true
		}

	case C_LACON:
		if b == C_SACON {
			return true
		}

	case C_LBRA:
		if b == C_SBRA {
			return true
		}

	case C_LAUTO:
		if b == C_SAUTO {
			return true
		}

	case C_LOREG:
		if b == C_ZOREG || b == C_SOREG {
			return true
		}

	case C_SOREG:
		if b == C_ZOREG {
			return true
		}

	case C_ANY:
		return true
	}

	return false
}

type ocmp []Optab

func (x ocmp) Len() int {
	return len(x)
}

func (x ocmp) Swap(i, j int) {
	x[i], x[j] = x[j], x[i]
}

func (x ocmp) Less(i, j int) bool {
	p1 := &x[i]
	p2 := &x[j]
	n := int(p1.as) - int(p2.as)
	if n != 0 {
		return n < 0
	}
	n = int(p1.a1) - int(p2.a1)
	if n != 0 {
		return n < 0
	}
	n = int(p1.a2) - int(p2.a2)
	if n != 0 {
		return n < 0
	}
	n = int(p1.a3) - int(p2.a3)
	if n != 0 {
		return n < 0
	}
	n = int(p1.a4) - int(p2.a4)
	if n != 0 {
		return n < 0
	}
	return false
}
func opset(a, b obj.As) {
	oprange[a&obj.AMask] = oprange[b&obj.AMask]
}

func buildop(ctxt *obj.Link) {
	if oprange[AORW&obj.AMask] != nil {
		// 已初始化；停下。
		// 这发生在cmd/asm测试中，
		// 每个测试都会重新初始化arch。
		return
	}

	for i := 0; i < C_NCLASS; i++ {
		for n := 0; n < C_NCLASS; n++ {
			if cmp(n, i) {
				xcmp[i][n] = true
			}
		}
	}
	sort.Sort(ocmp(optab))
	for i := 0; i < len(optab); i++ {
		r := optab[i].as
		start := i
		for ; i+1 < len(optab); i++ {
			if optab[i+1].as != r {
				break
			}
		}
		oprange[r&obj.AMask] = optab[start : i+1]

		// opset（）为类似指令的optab范围别名，以减少数组中optab的数量。
		// oplange[]由oplook（）用于查找适用于给定程序的Optab项。
		switch r {
		case AADD:
			opset(AADDC, r)
			opset(AADDW, r)
			opset(AADDE, r)
			opset(AMULLD, r)
			opset(AMULLW, r)
		case ADIVW:
			opset(ADIVD, r)
			opset(ADIVDU, r)
			opset(ADIVWU, r)
			opset(AMODD, r)
			opset(AMODDU, r)
			opset(AMODW, r)
			opset(AMODWU, r)
		case AMULHD:
			opset(AMULHDU, r)
		case AMOVBZ:
			opset(AMOVH, r)
			opset(AMOVHZ, r)
		case ALA:
			opset(ALAY, r)
		case AMVC:
			opset(AMVCIN, r)
			opset(ACLC, r)
			opset(AXC, r)
			opset(AOC, r)
			opset(ANC, r)
		case ASTCK:
			opset(ASTCKC, r)
			opset(ASTCKE, r)
			opset(ASTCKF, r)
		case ALAAG:
			opset(ALAA, r)
			opset(ALAAL, r)
			opset(ALAALG, r)
			opset(ALAN, r)
			opset(ALANG, r)
			opset(ALAX, r)
			opset(ALAXG, r)
			opset(ALAO, r)
			opset(ALAOG, r)
		case ASTMG:
			opset(ASTMY, r)
		case ALMG:
			opset(ALMY, r)
		case ABEQ:
			opset(ABGE, r)
			opset(ABGT, r)
			opset(ABLE, r)
			opset(ABLT, r)
			opset(ABNE, r)
			opset(ABVC, r)
			opset(ABVS, r)
			opset(ABLEU, r)
			opset(ABLTU, r)
		case ABR:
			opset(ABL, r)
		case ABC:
			opset(ABCL, r)
		case AFABS:
			opset(AFNABS, r)
			opset(ALPDFR, r)
			opset(ALNDFR, r)
			opset(AFNEG, r)
			opset(AFNEGS, r)
			opset(ALEDBR, r)
			opset(ALDEBR, r)
			opset(AFSQRT, r)
			opset(AFSQRTS, r)
		case AFADD:
			opset(AFADDS, r)
			opset(AFDIV, r)
			opset(AFDIVS, r)
			opset(AFSUB, r)
			opset(AFSUBS, r)
		case AFMADD:
			opset(AFMADDS, r)
			opset(AFMSUB, r)
			opset(AFMSUBS, r)
		case AFMUL:
			opset(AFMULS, r)
		case AFCMPO:
			opset(AFCMPU, r)
			opset(ACEBR, r)
		case AAND:
			opset(AOR, r)
			opset(AXOR, r)
		case AANDW:
			opset(AORW, r)
			opset(AXORW, r)
		case ASLD:
			opset(ASRD, r)
			opset(ASLW, r)
			opset(ASRW, r)
			opset(ASRAD, r)
			opset(ASRAW, r)
			opset(ARLL, r)
			opset(ARLLG, r)
		case ARNSBG:
			opset(ARXSBG, r)
			opset(AROSBG, r)
			opset(ARNSBGT, r)
			opset(ARXSBGT, r)
			opset(AROSBGT, r)
			opset(ARISBG, r)
			opset(ARISBGN, r)
			opset(ARISBGZ, r)
			opset(ARISBGNZ, r)
			opset(ARISBHG, r)
			opset(ARISBLG, r)
			opset(ARISBHGZ, r)
			opset(ARISBLGZ, r)
		case ACSG:
			opset(ACS, r)
		case ASUB:
			opset(ASUBC, r)
			opset(ASUBE, r)
			opset(ASUBW, r)
		case ANEG:
			opset(ANEGW, r)
		case AFMOVD:
			opset(AFMOVS, r)
		case AMOVDBR:
			opset(AMOVWBR, r)
		case ACMP:
			opset(ACMPW, r)
		case ACMPU:
			opset(ACMPWU, r)
		case ATMHH:
			opset(ATMHL, r)
			opset(ATMLH, r)
			opset(ATMLL, r)
		case ACEFBRA:
			opset(ACDFBRA, r)
			opset(ACEGBRA, r)
			opset(ACDGBRA, r)
			opset(ACELFBR, r)
			opset(ACDLFBR, r)
			opset(ACELGBR, r)
			opset(ACDLGBR, r)
		case ACFEBRA:
			opset(ACFDBRA, r)
			opset(ACGEBRA, r)
			opset(ACGDBRA, r)
			opset(ACLFEBR, r)
			opset(ACLFDBR, r)
			opset(ACLGEBR, r)
			opset(ACLGDBR, r)
		case AFIEBR:
			opset(AFIDBR, r)
		case ACMPBEQ:
			opset(ACMPBGE, r)
			opset(ACMPBGT, r)
			opset(ACMPBLE, r)
			opset(ACMPBLT, r)
			opset(ACMPBNE, r)
		case ACMPUBEQ:
			opset(ACMPUBGE, r)
			opset(ACMPUBGT, r)
			opset(ACMPUBLE, r)
			opset(ACMPUBLT, r)
			opset(ACMPUBNE, r)
		case ACGRJ:
			opset(ACRJ, r)
		case ACLGRJ:
			opset(ACLRJ, r)
		case ACGIJ:
			opset(ACIJ, r)
		case ACLGIJ:
			opset(ACLIJ, r)
		case AMOVDEQ:
			opset(AMOVDGE, r)
			opset(AMOVDGT, r)
			opset(AMOVDLE, r)
			opset(AMOVDLT, r)
			opset(AMOVDNE, r)
		case ALOCGR:
			opset(ALOCR, r)
		case ALTDBR:
			opset(ALTEBR, r)
		case ATCDB:
			opset(ATCEB, r)
		case AVL:
			opset(AVLLEZB, r)
			opset(AVLLEZH, r)
			opset(AVLLEZF, r)
			opset(AVLLEZG, r)
			opset(AVLREPB, r)
			opset(AVLREPH, r)
			opset(AVLREPF, r)
			opset(AVLREPG, r)
		case AVLEG:
			opset(AVLBB, r)
			opset(AVLEB, r)
			opset(AVLEH, r)
			opset(AVLEF, r)
			opset(AVLEG, r)
			opset(AVLREP, r)
		case AVSTEG:
			opset(AVSTEB, r)
			opset(AVSTEH, r)
			opset(AVSTEF, r)
		case AVSCEG:
			opset(AVSCEF, r)
		case AVGEG:
			opset(AVGEF, r)
		case AVESLG:
			opset(AVESLB, r)
			opset(AVESLH, r)
			opset(AVESLF, r)
			opset(AVERLLB, r)
			opset(AVERLLH, r)
			opset(AVERLLF, r)
			opset(AVERLLG, r)
			opset(AVESRAB, r)
			opset(AVESRAH, r)
			opset(AVESRAF, r)
			opset(AVESRAG, r)
			opset(AVESRLB, r)
			opset(AVESRLH, r)
			opset(AVESRLF, r)
			opset(AVESRLG, r)
		case AVLGVG:
			opset(AVLGVB, r)
			opset(AVLGVH, r)
			opset(AVLGVF, r)
		case AVLVGG:
			opset(AVLVGB, r)
			opset(AVLVGH, r)
			opset(AVLVGF, r)
		case AVZERO:
			opset(AVONE, r)
		case AVREPIG:
			opset(AVREPIB, r)
			opset(AVREPIH, r)
			opset(AVREPIF, r)
		case AVLEIG:
			opset(AVLEIB, r)
			opset(AVLEIH, r)
			opset(AVLEIF, r)
		case AVGMG:
			opset(AVGMB, r)
			opset(AVGMH, r)
			opset(AVGMF, r)
		case AVREPG:
			opset(AVREPB, r)
			opset(AVREPH, r)
			opset(AVREPF, r)
		case AVERIMG:
			opset(AVERIMB, r)
			opset(AVERIMH, r)
			opset(AVERIMF, r)
		case AVFTCIDB:
			opset(AWFTCIDB, r)
		case AVLR:
			opset(AVUPHB, r)
			opset(AVUPHH, r)
			opset(AVUPHF, r)
			opset(AVUPLHB, r)
			opset(AVUPLHH, r)
			opset(AVUPLHF, r)
			opset(AVUPLB, r)
			opset(AVUPLHW, r)
			opset(AVUPLF, r)
			opset(AVUPLLB, r)
			opset(AVUPLLH, r)
			opset(AVUPLLF, r)
			opset(AVCLZB, r)
			opset(AVCLZH, r)
			opset(AVCLZF, r)
			opset(AVCLZG, r)
			opset(AVCTZB, r)
			opset(AVCTZH, r)
			opset(AVCTZF, r)
			opset(AVCTZG, r)
			opset(AVLDEB, r)
			opset(AWLDEB, r)
			opset(AVFLCDB, r)
			opset(AWFLCDB, r)
			opset(AVFLNDB, r)
			opset(AWFLNDB, r)
			opset(AVFLPDB, r)
			opset(AWFLPDB, r)
			opset(AVFSQDB, r)
			opset(AWFSQDB, r)
			opset(AVISTRB, r)
			opset(AVISTRH, r)
			opset(AVISTRF, r)
			opset(AVISTRBS, r)
			opset(AVISTRHS, r)
			opset(AVISTRFS, r)
			opset(AVLCB, r)
			opset(AVLCH, r)
			opset(AVLCF, r)
			opset(AVLCG, r)
			opset(AVLPB, r)
			opset(AVLPH, r)
			opset(AVLPF, r)
			opset(AVLPG, r)
			opset(AVPOPCT, r)
			opset(AVSEGB, r)
			opset(AVSEGH, r)
			opset(AVSEGF, r)
		case AVECG:
			opset(AVECB, r)
			opset(AVECH, r)
			opset(AVECF, r)
			opset(AVECLB, r)
			opset(AVECLH, r)
			opset(AVECLF, r)
			opset(AVECLG, r)
			opset(AWFCDB, r)
			opset(AWFKDB, r)
		case AVCEQG:
			opset(AVCEQB, r)
			opset(AVCEQH, r)
			opset(AVCEQF, r)
			opset(AVCEQBS, r)
			opset(AVCEQHS, r)
			opset(AVCEQFS, r)
			opset(AVCEQGS, r)
			opset(AVCHB, r)
			opset(AVCHH, r)
			opset(AVCHF, r)
			opset(AVCHG, r)
			opset(AVCHBS, r)
			opset(AVCHHS, r)
			opset(AVCHFS, r)
			opset(AVCHGS, r)
			opset(AVCHLB, r)
			opset(AVCHLH, r)
			opset(AVCHLF, r)
			opset(AVCHLG, r)
			opset(AVCHLBS, r)
			opset(AVCHLHS, r)
			opset(AVCHLFS, r)
			opset(AVCHLGS, r)
		case AVFAEF:
			opset(AVFAEB, r)
			opset(AVFAEH, r)
			opset(AVFAEBS, r)
			opset(AVFAEHS, r)
			opset(AVFAEFS, r)
			opset(AVFAEZB, r)
			opset(AVFAEZH, r)
			opset(AVFAEZF, r)
			opset(AVFAEZBS, r)
			opset(AVFAEZHS, r)
			opset(AVFAEZFS, r)
			opset(AVFEEB, r)
			opset(AVFEEH, r)
			opset(AVFEEF, r)
			opset(AVFEEBS, r)
			opset(AVFEEHS, r)
			opset(AVFEEFS, r)
			opset(AVFEEZB, r)
			opset(AVFEEZH, r)
			opset(AVFEEZF, r)
			opset(AVFEEZBS, r)
			opset(AVFEEZHS, r)
			opset(AVFEEZFS, r)
			opset(AVFENEB, r)
			opset(AVFENEH, r)
			opset(AVFENEF, r)
			opset(AVFENEBS, r)
			opset(AVFENEHS, r)
			opset(AVFENEFS, r)
			opset(AVFENEZB, r)
			opset(AVFENEZH, r)
			opset(AVFENEZF, r)
			opset(AVFENEZBS, r)
			opset(AVFENEZHS, r)
			opset(AVFENEZFS, r)
		case AVPKSG:
			opset(AVPKSH, r)
			opset(AVPKSF, r)
			opset(AVPKSHS, r)
			opset(AVPKSFS, r)
			opset(AVPKSGS, r)
			opset(AVPKLSH, r)
			opset(AVPKLSF, r)
			opset(AVPKLSG, r)
			opset(AVPKLSHS, r)
			opset(AVPKLSFS, r)
			opset(AVPKLSGS, r)
		case AVAQ:
			opset(AVAB, r)
			opset(AVAH, r)
			opset(AVAF, r)
			opset(AVAG, r)
			opset(AVACCB, r)
			opset(AVACCH, r)
			opset(AVACCF, r)
			opset(AVACCG, r)
			opset(AVACCQ, r)
			opset(AVN, r)
			opset(AVNC, r)
			opset(AVAVGB, r)
			opset(AVAVGH, r)
			opset(AVAVGF, r)
			opset(AVAVGG, r)
			opset(AVAVGLB, r)
			opset(AVAVGLH, r)
			opset(AVAVGLF, r)
			opset(AVAVGLG, r)
			opset(AVCKSM, r)
			opset(AVX, r)
			opset(AVFADB, r)
			opset(AWFADB, r)
			opset(AVFCEDB, r)
			opset(AVFCEDBS, r)
			opset(AWFCEDB, r)
			opset(AWFCEDBS, r)
			opset(AVFCHDB, r)
			opset(AVFCHDBS, r)
			opset(AWFCHDB, r)
			opset(AWFCHDBS, r)
			opset(AVFCHEDB, r)
			opset(AVFCHEDBS, r)
			opset(AWFCHEDB, r)
			opset(AWFCHEDBS, r)
			opset(AVFMDB, r)
			opset(AWFMDB, r)
			opset(AVGFMB, r)
			opset(AVGFMH, r)
			opset(AVGFMF, r)
			opset(AVGFMG, r)
			opset(AVMXB, r)
			opset(AVMXH, r)
			opset(AVMXF, r)
			opset(AVMXG, r)
			opset(AVMXLB, r)
			opset(AVMXLH, r)
			opset(AVMXLF, r)
			opset(AVMXLG, r)
			opset(AVMNB, r)
			opset(AVMNH, r)
			opset(AVMNF, r)
			opset(AVMNG, r)
			opset(AVMNLB, r)
			opset(AVMNLH, r)
			opset(AVMNLF, r)
			opset(AVMNLG, r)
			opset(AVMRHB, r)
			opset(AVMRHH, r)
			opset(AVMRHF, r)
			opset(AVMRHG, r)
			opset(AVMRLB, r)
			opset(AVMRLH, r)
			opset(AVMRLF, r)
			opset(AVMRLG, r)
			opset(AVMEB, r)
			opset(AVMEH, r)
			opset(AVMEF, r)
			opset(AVMLEB, r)
			opset(AVMLEH, r)
			opset(AVMLEF, r)
			opset(AVMOB, r)
			opset(AVMOH, r)
			opset(AVMOF, r)
			opset(AVMLOB, r)
			opset(AVMLOH, r)
			opset(AVMLOF, r)
			opset(AVMHB, r)
			opset(AVMHH, r)
			opset(AVMHF, r)
			opset(AVMLHB, r)
			opset(AVMLHH, r)
			opset(AVMLHF, r)
			opset(AVMLH, r)
			opset(AVMLHW, r)
			opset(AVMLF, r)
			opset(AVNO, r)
			opset(AVO, r)
			opset(AVPKH, r)
			opset(AVPKF, r)
			opset(AVPKG, r)
			opset(AVSUMGH, r)
			opset(AVSUMGF, r)
			opset(AVSUMQF, r)
			opset(AVSUMQG, r)
			opset(AVSUMB, r)
			opset(AVSUMH, r)
		case AVERLLVG:
			opset(AVERLLVB, r)
			opset(AVERLLVH, r)
			opset(AVERLLVF, r)
			opset(AVESLVB, r)
			opset(AVESLVH, r)
			opset(AVESLVF, r)
			opset(AVESLVG, r)
			opset(AVESRAVB, r)
			opset(AVESRAVH, r)
			opset(AVESRAVF, r)
			opset(AVESRAVG, r)
			opset(AVESRLVB, r)
			opset(AVESRLVH, r)
			opset(AVESRLVF, r)
			opset(AVESRLVG, r)
			opset(AVFDDB, r)
			opset(AWFDDB, r)
			opset(AVFSDB, r)
			opset(AWFSDB, r)
			opset(AVSL, r)
			opset(AVSLB, r)
			opset(AVSRA, r)
			opset(AVSRAB, r)
			opset(AVSRL, r)
			opset(AVSRLB, r)
			opset(AVSB, r)
			opset(AVSH, r)
			opset(AVSF, r)
			opset(AVSG, r)
			opset(AVSQ, r)
			opset(AVSCBIB, r)
			opset(AVSCBIH, r)
			opset(AVSCBIF, r)
			opset(AVSCBIG, r)
			opset(AVSCBIQ, r)
		case AVACQ:
			opset(AVACCCQ, r)
			opset(AVGFMAB, r)
			opset(AVGFMAH, r)
			opset(AVGFMAF, r)
			opset(AVGFMAG, r)
			opset(AVMALB, r)
			opset(AVMALHW, r)
			opset(AVMALF, r)
			opset(AVMAHB, r)
			opset(AVMAHH, r)
			opset(AVMAHF, r)
			opset(AVMALHB, r)
			opset(AVMALHH, r)
			opset(AVMALHF, r)
			opset(AVMAEB, r)
			opset(AVMAEH, r)
			opset(AVMAEF, r)
			opset(AVMALEB, r)
			opset(AVMALEH, r)
			opset(AVMALEF, r)
			opset(AVMAOB, r)
			opset(AVMAOH, r)
			opset(AVMAOF, r)
			opset(AVMALOB, r)
			opset(AVMALOH, r)
			opset(AVMALOF, r)
			opset(AVSTRCB, r)
			opset(AVSTRCH, r)
			opset(AVSTRCF, r)
			opset(AVSTRCBS, r)
			opset(AVSTRCHS, r)
			opset(AVSTRCFS, r)
			opset(AVSTRCZB, r)
			opset(AVSTRCZH, r)
			opset(AVSTRCZF, r)
			opset(AVSTRCZBS, r)
			opset(AVSTRCZHS, r)
			opset(AVSTRCZFS, r)
			opset(AVSBCBIQ, r)
			opset(AVSBIQ, r)
			opset(AVMSLG, r)
			opset(AVMSLEG, r)
			opset(AVMSLOG, r)
			opset(AVMSLEOG, r)
		case AVSEL:
			opset(AVFMADB, r)
			opset(AWFMADB, r)
			opset(AVFMSDB, r)
			opset(AWFMSDB, r)
			opset(AVPERM, r)
		}
	}
}

const (
	op_A       uint32 = 0x5A00 // 格式RX1添加（32）
	op_AD      uint32 = 0x6A00 // 格式RX1添加规范化（长HFP）
	op_ADB     uint32 = 0xED1A // 格式RXE添加（长BFP）
	op_ADBR    uint32 = 0xB31A // 格式RRE添加（长BFP）
	op_ADTR    uint32 = 0xB3D2 // 格式RRF1添加（长DFP）
	op_AE      uint32 = 0x7A00 // 格式加规范化（短HFP）
	op_AEB     uint32 = 0xED0A // 格式加规范化（短BFP）
	op_AEBR    uint32 = 0xB30A // 格式加规范化（短HFP）
	op_AER     uint32 = 0x3A00 // 格式加规范化（短HFP）
	op_AG      uint32 = 0xE308 // 格式加规范化（64）
	op_AGFI    uint32 = 0xC208 // 格式（64<-32）
	op_AGFR    uint32 = 0xB918 // 格式（64<-32）
	op_AGHI    uint32 = 0xA70B // 格式（64<-32）
	op_AGHI    uint32 = 0xA70B // 格式（64）
	op_AGHIK   uint32 = 0xECD9 // 格式（64<-16）
	op_AGR     uint32 = 0xB908 // 格式（64）
	op_AH      uint32 = 0x4A00 // 格式加半字
	op_AHHHR   uint32 = 0xB9C8 // 格式加高（32）
	op_AHHLR   uint32 = 0xB9D8 // 格式加高（32）
	op_AHI     uint32 = 0xA70A // 格式加半字立即（32）
	op_AHIK    uint32 = 0xECD8 // 格式加立即（32<-16）
	op_AIH     uint32 = 0xCC08 // 格式RIL1添加立即高（32）
	op_AL      uint32 = 0x5E00 // 格式RX1添加逻辑（32）
	op_ALC     uint32 = 0xE398 // 格式RXY1添加逻辑带进位（32）
	op_ALCG    uint32 = 0xE388 // 格式RXY1添加逻辑带进位（64）
	op_ALCGR   uint32 = 0xB988 // 格式RRE添加逻辑带进位（64）
	op_ALCR    uint32 = 0xB998 // 格式RRE添加逻辑带进位进位（32）进位（32）进位（32）进位（32）进位（1518）进位（32）进位（32）进位（15）进位（64）进位（64）进位（1520）进位（64）进位（64）进位（64）进位（32）进位（1521）进位（1521）进位（32）进位（32）进位（32）进位）进位（64进位）进位（64）进位（64）进位（64）进位）进位（1520）进位）进位（64）进位）进位（64）进位）进位）进位立即（64<-16）
	op_ALGR    uint32 = 0xB90A // 格式添加逻辑（64）
	op_ALGRK   uint32 = 0xB9EA // 格式添加逻辑（64）
	op_ALGSI   uint32 = 0xEB7E // 格式添加带符号立即（64<-8）
	op_ALHHHR  uint32 = 0xB9CA // 格式添加逻辑高（32）
	op_ALHHLR  uint32 = 0xB9DA // 格式添加逻辑高（32）
	op_ALHSIK  uint32 = 0xECDA // 格式添加逻辑高带符号立即数（32<-16）
	op_ALR     uint32 = 0x1E00 // 格式加逻辑（32）
	op_ALRK    uint32 = 0xB9FA // 格式加逻辑（32）
	op_ALSI    uint32 = 0xEB6E // 格式加逻辑带符号立即数（32<-8）
	op_ALSIH   uint32 = 0xCC0A // 格式加逻辑带符号立即数高（32）
	op_ALSIHN  uint32 = 0xCC0B // 格式RIL1添加带符号立即数高的逻辑（32）
	op_ALY     uint32 = 0xE35E // 格式RXY1添加逻辑（32）
	op_AP      uint32 = 0xFA00 // 格式SS2添加十进制
	op_AR      uint32 = 0x1A00 // 格式RR添加（32）
	op_ARK     uint32 = 0xB9F8 // 格式RRF1添加（32）
	op_ASI     uint32 = 0xEB6A // 格式SIY添加立即数（32<-8）
	op_AU      uint32 = 0x7E00 // 格式RX1添加非标准化（短HFP）
	op_AUR     uint32 = 0x3E00 // 格式加非标准化（短HFP）
	op_AW      uint32 = 0x6E00 // 格式加RX1加非标准化（长HFP）
	op_AWR     uint32 = 0x2E00 // 格式加非标准化（长HFP）
	op_AXBR    uint32 = 0xB34A // 格式加（扩展BFP）
	op_AXR     uint32 = 0x3600 // 格式加标准化（扩展HFP）
	op_AXTRA   uint32 = 0xB3DA // 格式RRF1 ADD（扩展DFP）
	op_AY      uint32 = 0xE35A // 格式RXY1 ADD（32）
	op_BAKR    uint32 = 0xB240 // 格式RR分支和堆栈
	op_BAL     uint32 = 0x4500 // 格式RX1分支和链接
	op_BALR    uint32 = 0x0500 // 格式RR分支和链接
	op_BAS     uint32 = 0x4D00 // 格式RX1分支和保存
	op_BASR    uint32 = 0x0D00 // 格式分支和保存
	op_BASSM   uint32 = 0x0C00 // 格式RR分支和保存和设置模式
	op_BC      uint32 = 0x4700 // 格式RX2分支条件
	op_BCR     uint32 = 0x0700 // 格式RR分支条件
	op_BCT     uint32 = 0x4600 // 格式RX1分支计数（32）
	op_BCTG    uint32 = 0xE346 // 格式RXY1分支计数（64）
	op_BCTGR   uint32 = 0xB946 // 格式RR分支计数（64）
	op_BCTR    uint32 = 0x0600 // FORMAT_RR BRANCH ON COUNT（32）
	op_BPP     uint32 = 0xC700 // FORMAT_SMI BRANCH PREDICTION PRELOAD 
	op_BPRP    uint32 = 0xC500 // FORMAT_MII BRANCH PREDICTION RELATIVE PRELOAD 
	op_BRAS    uint32 = 0xA705 // FORMAT_RI2 BRANCH RELATIVE 
	op_BRASL   uint32 = 0xC005 // FORMAT_RIL2 BRANCH RELATIVE 
	op_BRC     uint32 = 0xA704 // FORMAT_RI3 BRANCH条件
	op_BRCL    uint32 = 0xC004 // FORMAT_RIL3 BRANCH RELATIVE ON CONDITION LONG 
	op_BRCT    uint32 = 0xA706 // FORMAT_RI2 BRANCH RELATIVE ON COUNT（32）
	op_BRCTG   uint32 = 0xA707 // FORMAT_RIL2 BRANCH RELATIVE ON COUNT（64）
	op_BRCTH   uint32 = 0xCC06 // FORMAT_RIL2 BRANCH RELATIVE ON COUNT HIGH（32）
	op_BRXHG   uint32 = 0xEC44 // FORMAT_RIE5 BRANCH RELATIVE ON INDEX HIGH（64）
	op_BRXLE   uint32 = 0x8500 // FORMAT_rie BRANCH RELATIVE ON INDEX LOW或EQ（32）
	op_BRXLG   uint32 = 0xEC45 // FORMAT_RIE5 BRANCH RELATIVE ON INDEX LOW或EQ（64）
	op_BSA     uint32 = 0xB25A // FORMAT_rie RRE BRANCH AND SET AUTHORITY 
	op_BXH     uint32 = 0x8600 // 格式RS1分支在指数高（32）
	op_BXHG    uint32 = 0xEB44 // 格式RSY1分支在指数高（64）
	op_BXLE    uint32 = 0x8700 // 格式RS1分支在指数低或相等（32）
	op_BXLEG   uint32 = 0xEB45 // 格式RSY1分支在指数低或相等（64）
	op_C       uint32 = 0x5900 // 格式RX1比较（32）
	op_CD      uint32 = 0x6900 // 格式比较（长HFP）
	op_CDB     uint32 = 0xED19 // 格式（长BFP）
	op_CDBR    uint32 = 0xB319 // 格式（长BFP）
	op_CDFBR   uint32 = 0xB395 // 格式（从固定（32到长BFP）
	op_CDFBRA  uint32 = 0xB395 // 格式（从固定（32到长BFP）
	op_CDFR    uint32 = 0xB3B5 // 格式（从固定（32到长HFP）
	op_CDGBR   uint32 = 0xB3A5 // 格式从固定格式转换（64到长BFP）
	op_CDGBRA  uint32 = 0xB3A5 // 格式从固定格式转换（64到长BFP）
	op_CDGR    uint32 = 0xB3C5 // 格式从固定格式转换（64到长HFP）
	op_CDGTR   uint32 = 0xB3F1 // 格式从固定格式转换（64到长DFP）
	op_CDLFBR  uint32 = 0xB391 // 格式从逻辑（32到长BFP）转换
	op_CDLFTR  uint32 = 0xB953 // 格式从逻辑（32到长DFP）转换
	op_CDLGBR  uint32 = 0xB3A1 // 格式从逻辑（64到长BFP）转换
	op_CDLGTR  uint32 = 0xB952 // 格式从逻辑（64到长DFP）转换
	op_CDS     uint32 = 0xBB00 // 格式比较双精度和交换（32）
	op_CDSG    uint32 = 0xEB3E // 格式比较双精度和交换（64）
	op_CDSTR   uint32 = 0xB3F3 // 格式转换从有符号压缩（64到长DFP）
	op_CDSY    uint32 = 0xEB31 // 格式比较双精度和交换（32）
	op_CDTR    uint32 = 0xB3E4 // 格式比较（长DFP）
	op_CDZT    uint32 = 0xEDAA // 格式从分区（到长DFP）
	op_CE      uint32 = 0x7900 // 格式从RX1比较（短HFP）
	op_CEB     uint32 = 0xED09 // 格式从RXE比较（短BFP）
	op_CEBR    uint32 = 0xB309 // 格式比较（短BFP）
	op_CEDTR   uint32 = 0xB3F4 // 格式比较有偏指数（长DFP）
	op_CEFBR   uint32 = 0xB394 // 格式从固定（32到短BFP）
	op_CEFBRA  uint32 = 0xB394 // 格式从固定（32到短BFP）
	op_CEFR    uint32 = 0xB3B4 // 格式从固定（32到短HFP）
	op_CEGBR   uint32 = 0xB3A4 // 格式转换为固定格式（64至短BFP）格式转换为固定格式（64至短BFP）格式转换为固定格式（64至短BFP）格式转换为固定格式（64至短HFP）格式转换为固定格式（64至短HFP）格式转换为逻辑格式（32至短BFP）格式转换为逻辑格式（64至短BFP）比较（短HFP）
	op_CEXTR   uint32 = 0xB3FC // 格式（扩展DFP）
	op_CFC     uint32 = 0xB21A // 格式（短HFP）
	op_CFDBR   uint32 = 0xB399 // 格式（长BFP到32）
	op_CFDBRA  uint32 = 0xB399 // 格式（长BFP到32）
	op_CFDR    uint32 = 0xB3B9 // 格式（长HFP到32）
	op_CFDTR   uint32 = 0xB941 // 格式RRF5转换为固定（长DFP转换为32）
	op_CFEBR   uint32 = 0xB398 // 格式RRF5转换为固定（短BFP转换为32）
	op_CFEBRA  uint32 = 0xB398 // 格式RRF5转换为固定（短BFP转换为32）
	op_CFI     uint32 = 0xC20D // 格式RR1比较立即（32）
	op_CFXBR   uint32 = 0xB39A // 格式RRF5转换为固定格式（扩展BFP到32）转换为固定格式（扩展BFP到32）转换为固定格式（扩展BFP到32）转换为固定格式（扩展HFP到32）转换为固定格式（扩展HFP到32）转换为固定格式（扩展DFP到32）转换为固定格式（长BFP到64）
	op_CGDBRA  uint32 = 0xB3A9 // 格式RRF5转换为固定格式（长BFP到64）
	op_CGDR    uint32 = 0xB3C9 // 格式RRF5转换为固定格式（长HFP到64）
	op_CGDTR   uint32 = 0xB3E1 // 格式RRF5转换为固定格式（长DFP到64）
	op_CGEBRA  uint32 = 0xB3A8 // 格式RRF5转换为固定格式（短BFP到64）
	op_CGER    uint32 = 0xB3C8 // 格式RRF5转换为固定格式（短HFP到64）
	op_CGF     uint32 = 0xE330 // 格式RXY1比较（64<-32）
	op_CGFR    uint32 = 0xB930 // 格式RRE比较（64<-32）
	op_CGH     uint32 = 0xE334 // 格式比较半字（64<-16）
	op_CGHI    uint32 = 0xA70F // 格式比较半字立即数（64<-16）
	op_CGHRL   uint32 = 0xC604 // 格式比较半字相对长（64<-16）
	op_CGIJ    uint32 = 0xEC7C // 格式3比较直接和分支相对（64<-8）
	op_CGIT    uint32 = 0xEC70 // 格式1比较直接和陷阱（64<-16）
	op_CGR     uint32 = 0xB920 // 格式3比较（64）
	op_CGRB    uint32 = 0xECE4 // 格式2比较和分支（64）
	op_CGRJ    uint32 = 0xEC64 // 格式2比较和分支相对（64）
	op_CGRL    uint32 = 0xC608 // 格式2比较相对长（64）
	op_CGRT    uint32 = 0xB960 // 格式\u RRF3比较和陷阱（64）
	op_CGXBR   uint32 = 0xB3AA // 格式\u RRF5转换为固定格式（扩展BFP到64）
	op_CGXBRA  uint32 = 0xB3AA // 格式\u RRF5转换为固定格式（扩展BFP到64）
	op_CGXTR   uint32 = 0xB3E9 // 格式\u RRF5转换为固定格式（扩展DFP到64）
	op_CGXTRA  uint32 = 0xB3E9 // 格式RRF5转换为固定格式（扩展DFP为64）
	op_CH      uint32 = 0x4900 // 格式RX1比较半字（32<-16）
	op_CHF     uint32 = 0xE3CD // 格式RXY1比较高（32）
	op_CHHR    uint32 = 0xB9CD // 格式RRE比较高（32）
	op_CHHSI   uint32 = 0xE554 // 格式SIL比较半字立即数（16）
	op_CHI     uint32 = 0xA70E // 格式RI1比较半字即时（32<-16）即时（32<-16）即时（32<-16）即时（32<-16）即时（32<-16）即时（32<-16）即时（32<-16）即时（32<-16）即时（32<-16）即时（32<-16）即时（32<-16）半字（32<-16）格式比较
	op_CIJ     uint32 = 0xEC7E // 格式3比较立即和分支相对（32<-8）
	op_CIT     uint32 = 0xEC72 // 格式1比较立即和陷阱（32<-16）
	op_CKSM    uint32 = 0xB241 // 格式R校验和
	op_CL      uint32 = 0x5500 // FORMAT_RX1 COMPARE LOGICAL（32）
	op_CLC     uint32 = 0xD500 // FORMAT_SS1 COMPARE LOGICAL（character）
	op_CLCL    uint32 = 0x0F00 // FORMAT_RR COMPARE LOGICAL LONG 
	op_CLCLE   uint32 = 0xA900 // FORMAT_RS1 COMPARE LOGICAL LONG EXTENDED 
	op_CLCLU   uint32 = 0xEB8F // FORMAT_RSY1 COMPARE LOGICAL LONG UNICODE 
	op_CLFDBR  uint32 = 0xB39D // FORMAT_RRF5转换为LOGICAL（长BFP到32）
	op_CLFDTR  uint32 = 0xB943 // 格式RRF5转换为逻辑（长DFP到32）
	op_CLFEBR  uint32 = 0xB39C // 格式RRF5转换为逻辑（短BFP到32）
	op_CLFHSI  uint32 = 0xE55D // 格式SIL比较逻辑立即数（32<-16）
	op_CLFXBR  uint32 = 0xB39E // 格式RRF5转换为逻辑（扩展BFP到32）
	op_CLFXTR  uint32 = 0xB94B // 格式RRF5转换为逻辑（扩展DFP到32）
	op_CLGF    uint32 = 0xE331 // 格式\u RXY1比较逻辑（64<-32）
	op_CLGFI   uint32 = 0xC20E // 格式\u RIL1比较逻辑立即数（64<-32）
	op_CLGFR   uint32 = 0xB931 // 格式\r比较逻辑（64<-32）
	op_CLGFRL  uint32 = 0xC60E // 格式\u RIL2比较逻辑相对长（64<-32）
	op_CLGHSI  uint32 = 0xE559 // 格式比较逻辑立即数（64<-16）
	op_CLGIB   uint32 = 0xECFD // 格式比较逻辑立即数和分支数（64<-8）
	op_CLGIJ   uint32 = 0xEC7D // 格式比较逻辑立即数和分支相对数（64<-8）
	op_CLGR    uint32 = 0xB921 // 格式比较逻辑（64）
	op_CLGRB   uint32 = 0xECE5 // 格式比较逻辑和分支（64）
	op_CLGRJ   uint32 = 0xEC65 // 格式比较逻辑和分支相对（64）
	op_CLGRL   uint32 = 0xC60A // 格式比较逻辑相对长（64）
	op_CLGRT   uint32 = 0xB961 // 格式比较逻辑和陷阱（64）
	op_CLGT    uint32 = 0xEB2B // 格式比较逻辑AND TRAP（64）
	op_CLGXBR  uint32 = 0xB3AE // 格式RRF5转换为逻辑（扩展BFP为64）
	op_CLGXTR  uint32 = 0xB94A // 格式RRF5转换为逻辑（扩展DFP为64）
	op_CLHF    uint32 = 0xE3CF // 格式RXY1比较逻辑高（32）
	op_CLHHR   uint32 = 0xB9CF // 格式RRE比较逻辑高（32）
	op_CLHHSI  uint32 = 0xE555 // 格式SIL比较逻辑立即数（16）
	op_CLHLR   uint32 = 0xB9DF // 格式比较逻辑高（32）
	op_CLHRL   uint32 = 0xC607 // 格式比较逻辑相对长（32<-16）
	op_CLI     uint32 = 0x9500 // 格式比较逻辑（立即数）
	op_CLIB    uint32 = 0xECFF // 格式比较逻辑立即数和分支（32<-8）
	op_CLIH    uint32 = 0xCC0F // 格式比较逻辑立即数高（32）
	op_CLIY    uint32 = 0xEB55 // 格式3比较逻辑（立即数）
	op_CLM     uint32 = 0xBD00 // 格式2比较逻辑字符。掩码下（低）
	op_CLMH    uint32 = 0xEB20 // 格式_RSY2比较逻辑字符。掩码下（高）
	op_CLMY    uint32 = 0xEB21 // 格式_RSY2比较逻辑字符。掩码下（低）
	op_CLR     uint32 = 0x1500 // 格式\u RR比较逻辑（32）
	op_CLRB    uint32 = 0xECF7 // 格式\u RRS比较逻辑和分支（32）
	op_CLRJ    uint32 = 0xEC77 // 格式\u RIE2比较逻辑和分支相对（32）
	op_CLRL    uint32 = 0xC60F // 格式\u RIL2比较逻辑相对长（32）
	op_CLST    uint32 = 0xB25D // FORMAT_-RRE COMPARE LOGICAL STRING 
	op_CLT     uint32 = 0xEB23 // FORMAT_-RSY2 COMPARE LOGICAL AND TRAP（32）
	op_CLY     uint32 = 0xE355 // FORMAT_-RXY1 COMPARE LOGICAL（32）
	op_CMPSC   uint32 = 0xB263 // FORMAT_-RRE COMPRESSION CALL 
	op_CP      uint32 = 0xF900 // FORMAT_-SS2 COMPARE DECIMAL 
	op_CPSDR   uint32 = 0xB372 // FORMAT_-RRF2 COPY SIGN（long）
	op_CPYA    uint32 = 0xB24D // 复制访问
	op_CR      uint32 = 0x1900 // FORMAT_RR COMPARE（32）
	op_CRB     uint32 = 0xECF6 // FORMAT_RRS COMPARE AND BRANCH（32）
	op_CRDTE   uint32 = 0xB98F // FORMAT_RRF2 COMPARE AND REPLACE DAT表项
	op_CRJ     uint32 = 0xEC76 // FORMAT_rre2 COMPARE AND BRANCH RELATIVE（32）
	op_CRT     uint32 = 0xB972 // 比较和陷阱（32）
	op_CS      uint32 = 0xBA00 // 格式RS1比较和交换（32）
	op_CSCH    uint32 = 0xB230 // 格式S清除子通道
	op_CSDTR   uint32 = 0xB3E3 // 格式RRF4转换为有符号压缩（长DFP到64）
	op_CSP     uint32 = 0xB250 // 格式比较交换和清除
	op_CSST    uint32 = 0xC802 // 格式SSF比较交换和存储
	op_CSXTR   uint32 = 0xB3EB // 格式RRF4转换为有符号压缩（扩展DFP到128）
	op_CSY     uint32 = 0xEB14 // 格式比较交换（32）
	op_CU12    uint32 = 0xB2A7 // 格式RRF3转换UTF-8转换为UTF-16 
	op_CU14    uint32 = 0xB9B0 // 格式\u RRF3将UTF-8转换为UTF-32 
	op_CU21    uint32 = 0xB2A6 // 格式\u RRF3将UTF-16转换为UTF-8 
	op_CU24    uint32 = 0xB9B1 // 格式\u RRF3将UTF-16转换为UTF-32 
	op_CU42    uint32 = 0xB9B3 // 格式\u RRE将UTF-32转换为UTF-16 
	op_CUSE    uint32 = 0xB257 // 格式比较直到子串等于
	op_CUTFU   uint32 = 0xB2A7 // 格式RRF3将UTF-8转换为UNICODE 
	op_CUUTF   uint32 = 0xB2A6 // 格式RRF3将UNICODE转换为UTF-8 
	op_CUXTR   uint32 = 0xB3EA // 格式转换为无符号压缩（扩展DFP到128）
	op_CVBG    uint32 = 0xE30E // 格式RXY1转换为二进制（64）
	op_CVBY    uint32 = 0xE306 // 格式RXY1转换为二进制（32）
	op_CVD     uint32 = 0x4E00 // 格式RX1转换为十进制（32）
	op_CVDG    uint32 = 0xE32E // 格式RXY1转换为十进制（64）
	op_CVDY    uint32 = 0xE326 // 格式RXY1转换为十进制（32）
	op_CXBR    uint32 = 0xB349 // 格式比较（扩展BFP）
	op_CXFBRA  uint32 = 0xB396 // FORMAT_RRF5从固定（32到扩展BFP）转换
	op_CXFR    uint32 = 0xB3B6 // FORMAT_RRE从固定（32到扩展HFP）转换
	op_CXGBRA  uint32 = 0xB3A6 // FORMAT_RRF5 CONVERT FROM FIXED（64到扩展BFP）
	op_CXGR    uint32 = 0xB3C6 // FORMAT_RRF5 CONVERT FROM FIXED（64到扩展HFP）
	op_CXGTR   uint32 = 0xB3F9 // FORMAT_RRF5 CONVERT FROM FIXED（64到扩展BFP）
	op_CXLFBR  uint32 = 0xB392 // FORMAT_RRF5 CONVERT FROM LOGICAL（32到扩展BFP）
	op_CXLFTR  uint32 = 0xB95B // 格式从逻辑（32到扩展DFP）转换
	op_CXLGBR  uint32 = 0xB3A2 // 格式从逻辑（64到扩展BFP）转换
	op_CXLGTR  uint32 = 0xB95A // 格式从逻辑（64到扩展DFP）转换
	op_CXR     uint32 = 0xB369 // 格式比较（扩展HFP）
	op_CXSTR   uint32 = 0xB3FB // 格式从有符号压缩格式转换（128到扩展DFP）
	op_CXTR    uint32 = 0xB3EC // 格式比较（扩展DFP）
	op_CXUTR   uint32 = 0xB3FA // 格式转换从无符号压缩（128到扩展DFP）
	op_CXZT    uint32 = 0xEDAB // 格式转换从分区（到扩展DFP）
	op_CZDT    uint32 = 0xEDA8 // 格式转换到分区（从长DFP）
	op_CZXT    uint32 = 0xEDA9 // 格式RX1 DIVIDE（32<-64）格式RX1 DIVIDE（长HFP）格式RX1 DIVIDE（长HFP）格式RX1 DIVIDE（长HFP）格式RX1 DIVIDE（长BFP）格式
	op_DL      uint32 = 0xE397 // FORMAT_RXY1 DIVIDE LOGICAL（32<-64）
	op_DLG     uint32 = 0xE387 // FORMAT_RXY1 DIVIDE LOGICAL（64<-128）
	op_DLGR    uint32 = 0xB987 // FORMAT_RXY1 DIVIDE LOGICAL（64<-64）
	op_DP      uint32 = 0xFD00 // FORMAT_SS2 DIVIDE十进制
	op_DR      uint32 = 0x1D00 // FORMAT_RXY1 DIVIDE SINGLE（64）
	op_DSGF    uint32 = 0xE31D // FORMAT_RXY1 DIVIDE SINGLE（64<-32）
	op_DSGFR   uint32 = 0xB91D // FORMAT_RR DIVIDE SINGLE（64<-32）
	op_DXBR    uint32 = 0xB34D // FORMAT_r DIVIDE ride SINGLEDIVIDE（扩展HFP）
	op_DXTR    uint32 = 0xB3D9 // FORMAT_RRF1 DIVIDE（扩展DFP）
	op_DXTRA   uint32 = 0xB3D9 // FORMAT_RRF1 DIVIDE（扩展DFP）
	op_EAR     uint32 = 0xB24F // FORMAT_RRE EXTRACT ACCESS 
	op_ECAG    uint32 = 0xEB4C // FORMAT_RSY1提取缓存属性
	op_ECTG    uint32 = 0xC801 // 格式SSF提取CPU时间
	op_ED      uint32 = 0xDE00 // 格式SS1编辑
	op_EDMK    uint32 = 0xDF00 // 格式SS1编辑并标记
	op_EEDTR   uint32 = 0xB3E5 // 格式RRE提取有偏指数（长DFP到64）
	op_EEXTR   uint32 = 0xB3ED // 格式RRE提取有偏指数（扩展DFP到64）
	op_EFPC    uint32 = 0xB38C // 格式RRE提取FPC 
	op_EPAIR   uint32 = 0xB99A // /格式提取主要ASN和实例
	op_EPAR    uint32 = 0xB226 // 格式提取主要ASN 
	op_EPSW    uint32 = 0xB98D // 格式提取PSW 
	op_EREG    uint32 = 0xB249 // 格式提取堆叠寄存器（32）
	op_EREGG   uint32 = 0xB90E // 格式提取堆叠寄存器（64）
	op_ESAIR   uint32 = 0xB99B // 格式提取次要ASN和实例
	op_ESAR    uint32 = 0xB227 // 格式提取次要ASN 
	op_ESDTR   uint32 = 0xB3E7 // 格式提取显著性（长DFP）
	op_ESEA    uint32 = 0xB99D // 格式提取并设置扩展权限
	op_ESTA    uint32 = 0xB24A // 格式提取堆叠状态
	op_ESXTR   uint32 = 0xB3EF // 格式提取显著性（扩展DFP）
	op_EX      uint32 = 0x4400 // 格式RX1执行
	op_EXRL    uint32 = 0xC600 // 格式RIL2执行相对长
	op_FIDBR   uint32 = 0xB35F // 格式RRF5加载FP整数（长BFP）
	op_FIDBRA  uint32 = 0xB35F // 格式RRF5加载FP整数（长BFP）
	op_FIDR    uint32 = 0xB37F // 格式RRR加载FP整数（长HFP）
	op_FIEBR   uint32 = 0xB357 // 格式RRF5加载FP整数（短BFP）
	op_FIEBRA  uint32 = 0xB357 // 格式RRF5加载FP整数（短BFP）
	op_FIER    uint32 = 0xB377 // 格式RRE加载FP整数（短HFP）
	op_FIXBRA  uint32 = 0xB347 // 格式RRF5加载FP整数（扩展BFP）
	op_FIXTR   uint32 = 0xB3DF // 格式_rrf5LOAD FP INTEGER（扩展DFP）
	op_FLOGR   uint32 = 0xB983 // 格式_RRE查找最左边的一个
	op_HDR     uint32 = 0x2400 // 格式_rrhalve（长HFP）
	op_HER     uint32 = 0x3400 // 格式_rrhalve（短HFP）
	op_HSCH    uint32 = 0xB231 // 格式_S暂停子通道
	op_IAC     uint32 = 0xB224 // 格式_RRE插入地址空格控制
	op_IC      uint32 = 0x4300 // 格式RX1插入字符
	op_ICM     uint32 = 0xBF00 // 格式RS2插入掩码下字符（低）
	op_ICMH    uint32 = 0xEB80 // 格式RSY2插入掩码下字符（高）
	op_ICMY    uint32 = 0xEB81 // 格式RSY2插入掩码下字符（低）
	op_ICY     uint32 = 0xE373 // 格式RXY1插入字符
	op_IDTE    uint32 = 0xB98E // 格式RRF2无效数据表项
	op_IEDTR   uint32 = 0xB3F6 // 格式RRF2插入有偏指数（64到长DFP）
	op_IEXTR   uint32 = 0xB3FE // 格式RRF2插入有偏指数（64到扩展DFP）
	op_IIHF    uint32 = 0xC008 // 格式RIL1插入立即数（高）
	op_IIHH    uint32 = 0xA500 // 格式RI1插入立即数（高-高）
	op_IIHL    uint32 = 0xA501 // 格式RI1插入立即数（高-低）
	op_IILF    uint32 = 0xC009 // 格式RIL1插入立即（低）
	op_IILH    uint32 = 0xA502 // 格式RIL1插入立即（低-高）
	op_IILL    uint32 = 0xA503 // 格式RIL1插入立即（低-低）
	op_IPK     uint32 = 0xB20B // 格式S插入PSW键
	op_IPM     uint32 = 0xB222 // 格式RRE插入程序掩码
	op_IPTE    uint32 = 0xB221 // 格式RRF1使页表条目无效
	op_ISKE    uint32 = 0xB229 // FORMAT_-RRE INSERT STORAGE KEY EXTENDED 
	op_IVSK    uint32 = 0xB223 // FORMAT_-RRE INSERT VIRTUAL STORAGE KEY 
	op_KDB     uint32 = 0xED18 // FORMAT_-RXE COMPARE AND SIGNAL（长BFP）
	op_KEB     uint32 = 0xED08 // FORMAT_-RXE COMPARE AND SIGNAL（长BFP）
	op_KEBR    uint32 = 0xB308 // 格式比较和信号（短BFP）
	op_KIMD    uint32 = 0xB93E // 格式计算中间消息摘要
	op_KLMD    uint32 = 0xB93F // 格式计算最后消息摘要
	op_KM      uint32 = 0xB92E // 格式加密消息
	op_KMAC    uint32 = 0xB91E // 格式计算消息验证码
	op_KMCTR   uint32 = 0xB92D // 使用计数器
	op_KMF     uint32 = 0xB92A // 使用CFB 
	op_KMO     uint32 = 0xB92B // 使用OFB 
	op_KXBR    uint32 = 0xB348 // 使用格式比较和信号（扩展BFP）
	op_KXTR    uint32 = 0xB3E8 // 使用格式比较和信号（扩展DFP）
	op_L       uint32 = 0x5800 // 格式RX1加载（32）
	op_LA      uint32 = 0x4100 // 格式RX1加载地址
	op_LAA     uint32 = 0xEBF8 // 格式RSY1加载并添加（32）
	op_LAAG    uint32 = 0xEBE8 // 格式RSY1加载并添加（64）
	op_LAAL    uint32 = 0xEBFA // 格式RSY1加载并添加逻辑（32）
	op_LAALG   uint32 = 0xEBEA // 格式RSY1加载并添加逻辑（64）
	op_LAE     uint32 = 0x5100 // 格式RX1加载地址扩展
	op_LAEY    uint32 = 0xE375 // 格式RSY1加载地址扩展
	op_LAM     uint32 = 0x9A00 // 格式RS1加载访问多
	op_LAMY    uint32 = 0xEB9A // 格式RSY1加载访问多
	op_LAN     uint32 = 0xEBF4 // 格式RSY1加载和（32）
	op_LANG    uint32 = 0xEBE4 // /FORMAT_RSY1 LOAD AND AND AND（64）
	op_LAO     uint32 = 0xEBF6 // FORMAT_RSY1 LOAD AND OR（32）
	op_LAOG    uint32 = 0xEBE6 // FORMAT_RSY1 LOAD AND OR（64）
	op_LARL    uint32 = 0xC000 // FORMAT_RIL2 LOAD ADDRESS RELATIVE LONG 
	op_LASP    uint32 = 0xE500 // FORMAT_SSE LOAD ADDRESS SPACE PARAMETERS 
	op_LAT     uint32 = 0xE39F // FORMAT_RXY1 LOAD AND TRAP（32L<-32）
	op_LAX     uint32 = 0xEBF7 // FORMAT_RSY1加载和异或（32）加载和异或（64）加载和异或（64）加载地址加载地址加载字节（32）加载字节（32）加载字节
	op_LCDFR   uint32 = 0xB373 // 格式RR加载补码（长）
	op_LCDR    uint32 = 0x2300 // 格式RR加载补码（长HFP）
	op_LCEBR   uint32 = 0xB303 // 格式RR加载补码（短BFP）
	op_LCER    uint32 = 0x3300 // 格式RR加载补码（短HFP）
	op_LCGFR   uint32 = 0xB913 // 格式RR加载补码（64<-32）
	op_LCGR    uint32 = 0xB903 // 格式RR加载补码（64）
	op_LCR     uint32 = 0x1300 // 格式RR加载补码（32）
	op_LCTL    uint32 = 0xB700 // 格式RS1加载控制（32）
	op_LCTLG   uint32 = 0xEB2F // 格式RSY1加载控制（64）
	op_LCXBR   uint32 = 0xB343 // 格式RR加载补码（扩展BFP）
	op_LD      uint32 = 0x6800 // 格式RX1加载（长）
	op_LDR     uint32 = 0x2800 // 格式\u RR加载（长）
	op_LDXBR   uint32 = 0xB345 // 格式\u RR加载四舍五入（扩展到长BFP）
	op_LDXBRA  uint32 = 0xB345 // 格式\u RRF5加载四舍五入（扩展到长BFP）
	op_LDY     uint32 = 0xED65 // 格式RXY1加载（长）
	op_LE      uint32 = 0x7800 // 格式RX1加载（短）
	op_LEDBR   uint32 = 0xB344 // 格式R加载四舍五入（长到短BFP）
	op_LEDBRA  uint32 = 0xB344 // 格式RRF5加载四舍五入（长到短BFP）
	op_LEDTR   uint32 = 0xB3D5 // 格式RRF5加载四舍五入（长到短DFP）
	op_LER     uint32 = 0x3800 // 格式RR加载（短）
	op_LEXBR   uint32 = 0xB346 // 格式RRE加载四舍五入（扩展到短BFP）
	op_LEXBRA  uint32 = 0xB346 // 格式RRF5加载四舍五入（扩展到短BFP）
	op_LEXR    uint32 = 0xB366 // 格式RRE加载四舍五入（扩展到短HFP）
	op_LEY     uint32 = 0xED64 // 格式RRXY1加载（短）
	op_LFH     uint32 = 0xE3CA // 格式\uRxy1加载高（32）
	op_LFHAT   uint32 = 0xE3C8 // 格式\uRxy1加载高和陷阱（32H<-32）
	op_LFPC    uint32 = 0xB29D // 格式\uRxy1加载FPC 
	op_LG      uint32 = 0xE304 // 格式\uRxy1加载高（64）
	op_LGB     uint32 = 0xE377 // 格式\uRxy1加载字节（64）
	op_LGDR    uint32 = 0xB3CD // 格式从FPR加载GR（长到64）
	op_LGF     uint32 = 0xE314 // 格式RXY1加载（64<-32）
	op_LGFI    uint32 = 0xC001 // 格式RIL1立即加载（64<-32）
	op_LGFR    uint32 = 0xB914 // 格式R加载（64<-32）
	op_LGFRL   uint32 = 0xC40C // 格式RIL2加载相对长（64<-32）
	op_LGHI    uint32 = 0xA709 // 格式加载半字立即（64）
	op_LGHR    uint32 = 0xB907 // 格式加载半字（64）
	op_LGHRL   uint32 = 0xC404 // 格式加载半字相对长（64<-16）
	op_LGR     uint32 = 0xB904 // 格式加载（64）
	op_LGRL    uint32 = 0xC408 // 格式加载相对长（64）
	op_LH      uint32 = 0x4800 // 格式加载半字（32）
	op_LHH     uint32 = 0xE3C4 // 格式加载半字高（32<-16）
	op_LHI     uint32 = 0xA708 // 格式加载半字立即（32）
	op_LHR     uint32 = 0xB927 // 格式加载半字（32）
	op_LHRL    uint32 = 0xC405 // 格式加载半字相对长（32<-16）
	op_LHY     uint32 = 0xE378 // 格式RXY1加载半字（32）
	op_LLC     uint32 = 0xE394 // 格式RXY1加载逻辑字符（32）
	op_LLCH    uint32 = 0xE3C2 // 格式RXY1加载逻辑字符高（32<-8）
	op_LLCR    uint32 = 0xB994 // 格式R加载逻辑字符（32）
	op_LLGC    uint32 = 0xE390 // 格式RXY1加载逻辑字符（64）
	op_LLGCR   uint32 = 0xB984 // 格式R加载逻辑字符（64）
	op_LLGF    uint32 = 0xE316 // 格式RXY1加载逻辑（64<-32）
	op_LLGFAT  uint32 = 0xE39D // 格式RXY1加载逻辑和陷阱（64<-32）
	op_LLGFR   uint32 = 0xB916 // 格式R加载逻辑（64<-32）
	op_LLGFRL  uint32 = 0xC40E // 格式R加载逻辑相对长（64<-32）
	op_LLGHR   uint32 = 0xB985 // 格式R加载逻辑半字（64）
	op_LLGHRL  uint32 = 0xC406 // 格式RIL2加载逻辑半字相对长（64<-16）
	op_LLGT    uint32 = 0xE317 // 格式RXY1加载逻辑31位
	op_LLGTAT  uint32 = 0xE39C // 格式RXY1加载逻辑31位和陷阱（64<-31）
	op_LLH     uint32 = 0xE395 // 格式RXY1加载逻辑半字（32）
	op_LLHH    uint32 = 0xE3C6 // FORMAT_RXY1 LOAD LOGICAL HALFWORD HIGH（32<-16）
	op_LLHR    uint32 = 0xB995 // FORMAT_RRE LOAD LOGICAL HALFWORD（32）
	op_LLHRL   uint32 = 0xC402 // FORMAT_ry2 LOAD LOGICAL HALFWORD RELATIVE LONG（32<-16）
	op_LLIHH   uint32 = 0xA50C // FORMAT_r1 LOAD LOGICAL IMMEDIATE（高）
	op_LLIHL   uint32 = 0xA50D // 格式1加载逻辑立即数（高低）
	op_LLILF   uint32 = 0xC00F // 格式1加载逻辑立即数（低）
	op_LLILH   uint32 = 0xA50E // 格式1加载逻辑立即数（高低）
	op_LLILL   uint32 = 0xA50F // 格式1加载逻辑立即数（高低）
	op_LM      uint32 = 0x9800 // 格式1加载倍数（32）
	op_LMD     uint32 = 0xEF00 // 格式5加载多个不相交的
	op_LMG     uint32 = 0xEB04 // 格式RSY1加载多个（64）
	op_LMH     uint32 = 0xEB96 // 格式RSY1加载多个高
	op_LMY     uint32 = 0xEB98 // 格式RSY1加载多个（32）
	op_LNDBR   uint32 = 0xB311 // 格式R加载负（长BFP）
	op_LNDR    uint32 = 0x2100 // 格式R加载负（长HFP）
	op_LNEBR   uint32 = 0xB301 // 格式负负荷（短BFP）
	op_LNGFR   uint32 = 0xB911 // 格式负负荷（64<-32）
	op_LNGR    uint32 = 0xB901 // 格式负负荷（64）
	op_LNR     uint32 = 0x1100 // 格式负负荷（32）
	op_LNXR    uint32 = 0xB361 // 格式RSY2条件加载（32）
	op_LOCG    uint32 = 0xEBE2 // 格式RSY2条件加载（64）
	op_LOCGR   uint32 = 0xB9E2 // 格式RRF3条件加载（64）
	op_LOCR    uint32 = 0xB9F2 // 格式RRF3条件加载（32）
	op_LPD     uint32 = 0xC804 // 格式SSF条件加载对不相交（32）
	op_LPDBR   uint32 = 0xB310 // 格式正载（长BFP）
	op_LPDFR   uint32 = 0xB370 // 格式正载（长）
	op_LPDG    uint32 = 0xC805 // 格式负载（64）
	op_LPDR    uint32 = 0x2000 // 格式正载（长HFP）
	op_LPEBR   uint32 = 0xB300 // 格式正载（短BFP）
	op_LPER    uint32 = 0x3000 // 格式正载（短HFP）
	op_LPGFR   uint32 = 0xB910 // 格式为正加载（64<-32）
	op_LPGR    uint32 = 0xB900 // 格式为正加载（64）
	op_LPQ     uint32 = 0xE38F // 格式为四字
	op_LPR     uint32 = 0x1000 // 格式为正加载（32）
	op_LPSW    uint32 = 0x8200 // 格式为PSW 
	op_LPSWE   uint32 = 0xB2B2 // 格式为PSW扩展
	op_LPTEA   uint32 = 0xB9AA // 格式为RRF2加载页表条目地址
	op_LPXBR   uint32 = 0xB340 // 格式RER加载正（扩展BFP）
	op_LPXR    uint32 = 0xB360 // 格式RER加载正（扩展HFP）
	op_LR      uint32 = 0x1800 // 格式RER加载（32）
	op_LRA     uint32 = 0xB100 // 格式REX1加载实地址（32）
	op_LRAG    uint32 = 0xE303 // 格式REXY1加载实地址（64）
	op_LRDR    uint32 = 0x2500 // 格式（扩展到长HFP）
	op_LRER    uint32 = 0x3500 // 格式（长到短HFP）
	op_LRL     uint32 = 0xC40D // 格式（RIL2）加载相对长（32）
	op_LRV     uint32 = 0xE31E // 格式（32）
	op_LRVG    uint32 = 0xE30F // 格式（64）
	op_LRVGR   uint32 = 0xB90F // 格式反向（64）反向（64）反向（64）反向（32）反向（32）反向（32）反向（32）反向（32）反向（32）反向（32）反向（32）反向（32）反向（32）反向加载和测试
	op_LTDR    uint32 = 0x2200 // FORMAT_-RR LOAD AND TEST（长HFP）
	op_LTGFR   uint32 = 0xB912 // 格式RRE加载和测试（64<-32）
	op_LTGR    uint32 = 0xB902 // 格式RRE加载和测试（64）
	op_LTR     uint32 = 0x1200 // 格式RRE加载和测试（32）
	op_LTXBR   uint32 = 0xB342 // 格式RRE加载和测试（扩展BFP）
	op_LTXTR   uint32 = 0xB3DE // 格式RRE加载和测试（扩展DFP）
	op_LURA    uint32 = 0xB24B // 使用实地址进行格式化加载（32）
	op_LURAG   uint32 = 0xB905 // 使用实地址进行格式化加载（64）
	op_LXD     uint32 = 0xED25 // 格式化加载加长（长到扩展HFP）
	op_LXDB    uint32 = 0xED05 // 格式化加载加长（长到扩展BFP）
	op_LXDBR   uint32 = 0xB305 // 格式化加载加长（长到扩展BFP）
	op_LXR     uint32 = 0xB365 // 格式RRE加载（扩展）
	op_LY      uint32 = 0xE358 // 格式RRY加载（32）
	op_LZDR    uint32 = 0xB375 // 格式RRE加载零（长）
	op_LZER    uint32 = 0xB374 // 格式RRE加载零（短）
	op_LZXR    uint32 = 0xB376 // 格式RRE加载零（扩展）
	op_M       uint32 = 0x5C00 // 格式乘法（64<-32）
	op_MAD     uint32 = 0xED3E // 格式（长HFP）
	op_MADB    uint32 = 0xED1E // 格式（长BFP）
	op_MADBR   uint32 = 0xB31E // 格式（长BFP）
	op_MADBR   uint32 = 0xB31E // 格式（长BFP）
	op_MAE     uint32 = 0xED2E // 格式（长HFP）
	op_MAEB    uint32 = 0xED0E // 格式（长HFP）乘法和加法（短BFP）
	op_MAEBR   uint32 = 0xB30E // 格式RRD乘法和加法（短BFP）
	op_MAER    uint32 = 0xB32E // 格式RRD乘法和加法（短HFP）
	op_MAY     uint32 = 0xED3A // 格式RXF乘法和加法非规范化（长到外部HFP）
	op_MAYHR   uint32 = 0xB33C // 格式\u RRD乘法和加法unrm。（长到外部高HFP）
	op_MAYL    uint32 = 0xED38 // 格式为乘法和加法UNNRM。（长到外部低HFP）
	op_MAYLR   uint32 = 0xB338 // 格式为乘法和加法UNNRM。（long to ext.low HFP）
	op_MAYR    uint32 = 0xB33A // 格式化（长到ext.HFP）
	op_MC      uint32 = 0xAF00 // 格式化（监控）调用
	op_MD      uint32 = 0x6C00 // 格式化（长HFP）
	op_MDB     uint32 = 0xED1C // 格式化（长BFP）
	op_MDBR    uint32 = 0xB31C // 格式化（长BFP）
	op_MDEB    uint32 = 0xED0C // 格式（短到长的BFP）
	op_MDEBR   uint32 = 0xB30C // 格式（短到长的BFP）
	op_MDER    uint32 = 0x3C00 // 格式（短到长的HFP）
	op_MDR     uint32 = 0x2C00 // 格式（长的HFP）
	op_MDTR    uint32 = 0xB3D0 // 格式（长的DFP）
	op_ME      uint32 = 0x7C00 // 格式RX1乘法（短到长HFP）
	op_MEE     uint32 = 0xED37 // 格式RXE乘法（短HFP）
	op_MEEB    uint32 = 0xED17 // 格式RXE乘法（短BFP）
	op_MEEBR   uint32 = 0xB317 // 格式RRE乘法（短BFP）
	op_MEER    uint32 = 0xB337 // 格式RRE乘法（短HFP）
	op_MFY     uint32 = 0xE35C // 格式（64<-32）
	op_MGHI    uint32 = 0xA70D // 格式（64）
	op_MH      uint32 = 0x4C00 // 格式（32）
	op_MHY     uint32 = 0xE37C // 格式（32）
	op_MLG     uint32 = 0xE386 // 格式RXY1乘法逻辑（128<-64）
	op_MLGR    uint32 = 0xB986 // 格式R乘法逻辑（128<-64）
	op_MLR     uint32 = 0xB996 // 格式R乘法逻辑（64<-32）
	op_MP      uint32 = 0xFC00 // 格式SS2乘法十进制
	op_MR      uint32 = 0x1C00 // 格式R乘法（64<-32）
	op_MS      uint32 = 0x7100 // 格式R乘法单个（32）
	op_MSCH    uint32 = 0xB232 // 格式修改子通道
	op_MSD     uint32 = 0xED3F // 格式RXF乘法和减法（长HFP）
	op_MSDB    uint32 = 0xED1F // 格式RXF乘法和减法（长BFP）
	op_MSDBR   uint32 = 0xB31F // 格式RRD乘法和减法（长BFP）
	op_MSDR    uint32 = 0xB33F // 格式RXF乘法和减法（长HFP）
	op_MSE     uint32 = 0xED2F // 格式RXF乘法和减法（短HFP）
	op_MSEB    uint32 = 0xED0F // 格式RXF乘法和减法（短BFP）
	op_MSEBR   uint32 = 0xB30F // 格式RRD乘法和减法（短BFP）
	op_MSER    uint32 = 0xB32F // 格式RRD乘法和减法（短HFP）
	op_MSFI    uint32 = 0xC201 // 格式RR1乘法单立即数（32）
	op_MSGF    uint32 = 0xE31C // 格式RXY1乘法单（64<-32）
	op_MSGFI   uint32 = 0xC200 // 格式\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\
	op_MVCDK   uint32 = 0xE50F // FORMAT_SS1 MOVE WITH DESTINATION KEY 
	op_MVCIN   uint32 = 0xE800 // FORMAT_SS1 MOVE INVERSE 
	op_MVCK    uint32 = 0xD900 // FORMAT_SS4 MOVE WITH KEY 
	op_MVCL    uint32 = 0x0E00 // FORMAT_RR MOVE LONG 
	op_MVCLE   uint32 = 0xA800 // FORMAT_RS1 MOVE LONG EXTENDED 
	op_MVCLU   uint32 = 0xEB8E // FORMAT_RSY1 MOVE LONG UNICODE
	op_MVCOS   uint32 = 0xC800 // 格式SSF移动带可选规格
	op_MVCP    uint32 = 0xDA00 // 格式SS4移动到主
	op_MVCS    uint32 = 0xDB00 // 格式SS4移动到辅助
	op_MVCSK   uint32 = 0xE50E // 格式SSF移动带源键
	op_MVGHI   uint32 = 0xE548 // 格式SIL移动（64<-16）
	op_MVHHI   uint32 = 0xE544 // 格式SIL移动（16<-16）
	op_MVHI    uint32 = 0xE54C // 格式SILMOVE（32<-16）
	op_MVI     uint32 = 0x9200 // FORMAT_-SI MOVE（immediate）
	op_MVIY    uint32 = 0xEB52 // FORMAT_-SIY MOVE（immediate）
	op_MVN     uint32 = 0xD100 // FORMAT_SS1 MOVE NUMERICS 
	op_MVO     uint32 = 0xF100 // FORMAT_SS2 MOVE WITH OFFSET 
	op_MVPG    uint32 = 0xB254 // FORMAT_-RRE MOVE PAGE 
	op_MVST    uint32 = 0xB255 // FORMAT_-RRE MOVE STRING 
	op_MXBR    uint32 = 0xB34C // 格式RER乘法（扩展BFP）
	op_MXD     uint32 = 0x6700 // 格式RX1乘法（长到扩展HFP）
	op_MXDB    uint32 = 0xED07 // 格式REXE乘法（长到扩展BFP）
	op_MXDBR   uint32 = 0xB307 // 格式RER乘法（长到扩展BFP）
	op_MXDR    uint32 = 0x2700 // 格式RER乘法（长到扩展HFP）
	op_MXTR    uint32 = 0xB3D8 // 格式RRF1乘法（扩展DFP）
	op_MXTRA   uint32 = 0xB3D8 // 格式RRF1乘法（扩展DFP）
	op_MY      uint32 = 0xED3B // 格式RXF乘法非规范化（长到外部HFP）
	op_MYH     uint32 = 0xED3D // 格式RXF乘法非规范化。（长到外部高HFP）
	op_MYHR    uint32 = 0xB33D // 格式不规则。（长到外部高HFP）
	op_MYL     uint32 = 0xED39 // 格式不规则。（长到外部低HFP）
	op_MYLR    uint32 = 0xB339 // 格式不规则。（long to ext.low HFP）
	op_MYR     uint32 = 0xB33B // 格式（long to ext.HFP）
	op_N       uint32 = 0x5400 // 格式RX1和（32）
	op_NC      uint32 = 0xD400 // 格式SS1和（字符）
	op_NG      uint32 = 0xE380 // 格式RXY1和（64）
	op_NGR     uint32 = 0xB980 // 格式和（64）
	op_NGRK    uint32 = 0xB9E4 // 格式和（立即）
	op_NIAI    uint32 = 0xB2FA // 格式（即下一条指令访问意图
	op_NIHF    uint32 = 0xC00A // 格式RIL1和立即（高）
	op_NIHH    uint32 = 0xA504 // 格式RI1和立即（高-高）
	op_NIHL    uint32 = 0xA505 // 格式RI1和立即（高-低）
	op_NILH    uint32 = 0xA506 // 格式RI1和立即（低-高）
	op_NILL    uint32 = 0xA507 // 格式RI1和立即（低-低）
	op_NIY     uint32 = 0xEB54 // 格式SIY和（立即）
	op_NR      uint32 = 0x1400 // 格式RR和（32）
	op_NRK     uint32 = 0xB9F4 // 格式RRF1和（32）
	op_NTSTG   uint32 = 0xE325 // 格式RXY1非交易存储
	op_NY      uint32 = 0xE354 // 格式RRXY1和（32）
	op_OC      uint32 = 0xD600 // 格式SS1或（字符）
	op_OG      uint32 = 0xE381 // 格式RXY1或（64）
	op_OGR     uint32 = 0xB981 // 格式RRE或（64）
	op_OGRK    uint32 = 0xB9E6 // 格式RRF1或（64）
	op_OIHL    uint32 = 0xA509 // 格式为RI1或立即（高低）
	op_OILF    uint32 = 0xC00D // 格式为RIL1或立即（低）
	op_OILH    uint32 = 0xA50A // 格式RI1或立即（低-高）
	op_OILL    uint32 = 0xA50B // 格式RI1或立即（低-低）
	op_OIY     uint32 = 0xEB56 // 格式SIY或（立即）
	op_OR      uint32 = 0x1600 // 格式RR或（32）
	op_ORK     uint32 = 0xB9F6 // 格式RRF1或（32）
	op_OY      uint32 = 0xE356 // 格式RXY1或（32）
	op_PACK    uint32 = 0xF200 // 格式SS2包装
	op_PC      uint32 = 0xB218 // 格式化程序调用
	op_PCC     uint32 = 0xB92C // 格式化执行加密计算
	op_PCKMO   uint32 = 0xB928 // 格式化执行加密密钥管理。操作
	op_PFD     uint32 = 0xE336 // FORMAT_xy2预取数据
	op_PFDRL   uint32 = 0xC602 // FORMAT_3预取数据相对长
	op_PFMF    uint32 = 0xB9AF // FORMAT_R执行帧管理函数
	op_PFPO    uint32 = 0x010A // FORMAT_R执行浮点操作
	op_PGIN    uint32 = 0xB22E // FORMAT_R页面在
	op_PGOUT   uint32 = 0xB22F // FORMAT_R页面在
	op_PKA     uint32 = 0xE900 // 格式SS6 PACK ASCII 
	op_PKU     uint32 = 0xE100 // 格式SS6 PACK UNICODE 
	op_PLO     uint32 = 0xEE00 // 格式SS5执行锁定操作
	op_POPCNT  uint32 = 0xB9E1 // 格式人口计数
	op_PPA     uint32 = 0xB2E8 // 格式RRF3执行处理器辅助
	op_PR      uint32 = 0x0101 // 格式E程序返回
	op_PT      uint32 = 0xB228 // 格式传输
	op_PTF     uint32 = 0xB9A2 // 格式执行拓扑函数
	op_PTFF    uint32 = 0x0104 // 格式执行定时工具函数
	op_PTI     uint32 = 0xB99E // 格式使用实例进行程序传输
	op_PTLB    uint32 = 0xB20D // 格式清除TLB 
	op_QADTR   uint32 = 0xB3F5 // 格式RRF2量化（长DFP）
	op_QAXTR   uint32 = 0xB3FD // 格式RRF2量化（扩展DFP）
	op_RCHP    uint32 = 0xB23B // 格式化重置通道路径
	op_RISBG   uint32 = 0xEC55 // 格式化旋转后插入选定位
	op_RISBGN  uint32 = 0xEC59 // 格式化旋转后插入选定位
	op_RISBHG  uint32 = 0xEC5D // 格式化旋转后插入选定位高
	op_RISBLG  uint32 = 0xEC51 // 格式化旋转后插入选定位低
	op_RLL     uint32 = 0xEB1D // 格式化RSY1旋转左单逻辑（32）
	op_RLLG    uint32 = 0xEB1C // 格式旋转左单逻辑（64）
	op_RNSBG   uint32 = 0xEC54 // 格式旋转然后选择位
	op_ROSBG   uint32 = 0xEC56 // 格式旋转然后或选择位
	op_RP      uint32 = 0xB277 // 格式恢复程序
	op_RRBE    uint32 = 0xB22A // 格式重新设置参考位扩展
	op_RRDTR   uint32 = 0xB3F7 // FORMAT_RRF2 REROUND（long DFP）
	op_RRXTR   uint32 = 0xB3FF // FORMAT_RRF2 REROUND（extended DFP）
	op_RSCH    uint32 = 0xB238 // FORMAT_S RESUME SUBCHANNEL 
	op_RXSBG   uint32 = 0xEC57 // FORMATMAT_rre6旋转然后排他位或选定位
	op_S       uint32 = 0x5B00 // FORMAT_RX1减去（32）
	op_SACF    uint32 = 0xB279 // 格式设置地址空间控制快速
	op_SAL     uint32 = 0xB237 // 格式设置地址限制
	op_SAM24   uint32 = 0x010C // 格式设置寻址模式（24）
	op_SAM31   uint32 = 0x010D // 格式设置寻址模式（31）
	op_SAM64   uint32 = 0x010E // 格式设置寻址模式（64）
	op_SAR     uint32 = 0xB24E // 格式SET ACCESS 
	op_SCHM    uint32 = 0xB23C // 格式化设置通道监视器
	op_SCK     uint32 = 0xB204 // 格式化设置时钟
	op_SCKC    uint32 = 0xB206 // 格式化设置时钟比较器
	op_SCKPF   uint32 = 0x0107 // 格式化设置时钟可编程字段
	op_SD      uint32 = 0x6B00 // 格式化设置时钟减去标准化（长HFP）
	op_SDB     uint32 = 0xED1B // 格式化设置时钟减去（长BFP）
	op_SDBR    uint32 = 0xB31B // 格式RR减法（长DFP）
	op_SDR     uint32 = 0x2B00 // 格式RR减法规范化（长HFP）
	op_SDTR    uint32 = 0xB3D3 // 格式RRF1减法（长DFP）
	op_SDTRA   uint32 = 0xB3D3 // 格式RRF1减法（长DFP）
	op_SEB     uint32 = 0xED0B // 格式RRXE减法（短BFP）
	op_SEBR    uint32 = 0xB30B // FORMAT_-RRE SUBTRACT（短BFP）
	op_SER     uint32 = 0x3B00 // FORMAT_-RR SUBTRACT NORMALIZED（短HFP）
	op_SFASR   uint32 = 0xB385 // FORMAT_-RRE SET FPC AND SIGNAL 
	op_SFPC    uint32 = 0xB384 // FORMAT_-RRE SET FPC 
	op_SG      uint32 = 0xE309 // FORMAT_RXY1 SUBTRACT（64）
	op_SGF     uint32 = 0xE319 // FORMAT_RXY1 SUBTRACT（64<-32）
	op_SGR     uint32 = 0xB909 // 格式（64）
	op_SGRK    uint32 = 0xB9E9 // 格式（64）
	op_SH      uint32 = 0x4B00 // 格式（RX1）减半字
	op_SHHHR   uint32 = 0xB9C9 // 格式（RRF1）减半字
	op_SL      uint32 = 0x5F00 // FORMAT_RX1 SHIFT-LEFT-SINGLE（32）
	op_SLAG    uint32 = 0xEB0B // FORMAT_RX1 SHIFT-LEFT-SINGLE（64）
	op_SLAK    uint32 = 0xEBDD // FORMAT_RX1 SHIFT-LEFT-SINGLE（32）
	op_SLB     uint32 = 0xE399 // FORMAT_RXY1用借位减去逻辑（32）
	op_SLBG    uint32 = 0xE389 // FORMAT_RXY1用借位减去逻辑（64）
	op_SLBGR   uint32 = 0xB989 // 格式R减去逻辑带借位（64）
	op_SLBR    uint32 = 0xB999 // 格式R减去逻辑带借位（32）
	op_SLDA    uint32 = 0x8F00 // 格式RS1左移双
	op_SLDL    uint32 = 0x8D00 // 格式RS1左移双逻辑
	op_SLDT    uint32 = 0xED40 // 格式R左移有效位（长DFP）
	op_SLHHHR  uint32 = 0xB9CB // 格式RRF1减去逻辑高位（32）
	op_SLHHLR  uint32 = 0xB9DB // 格式RRF1减去逻辑高位（32）
	op_SLL     uint32 = 0x8900 // 格式RS1左移单逻辑（32）
	op_SLLK    uint32 = 0xEBDF // 格式RSY1左移单逻辑（32）
	op_SLR     uint32 = 0x1F00 // 格式RR减去逻辑（32）
	op_SLRK    uint32 = 0xB9FB // 格式RRF1减去逻辑（32）
	op_SLXT    uint32 = 0xED48 // 格式RXF左移有效位（扩展DFP）
	op_SLY     uint32 = 0xE35F // 格式RXY1减去逻辑（32）
	op_SP      uint32 = 0xFB00 // 格式SS2减去十进制
	op_SPKA    uint32 = 0xB20A // 格式从地址
	op_SPM     uint32 = 0x0400 // 格式设置程序掩码
	op_SPT     uint32 = 0xB208 // 格式设置CPU定时器
	op_SPX     uint32 = 0xB210 // 格式设置前缀
	op_SQD     uint32 = 0xED35 // 格式设置平方根（长HFP）
	op_SQDB    uint32 = 0xED15 // 格式设置平方根（长BFP）
	op_SQDBR   uint32 = 0xB315 // 格式设置平方根（长BFP）
	op_SQDR    uint32 = 0xB244 // 格式根（长HFP）
	op_SQE     uint32 = 0xED34 // 格式（短HFP）
	op_SQEB    uint32 = 0xED14 // 格式（短BFP）
	op_SQEBR   uint32 = 0xB314 // 格式（短BFP）
	op_SQER    uint32 = 0xB245 // 格式（短HFP）
	op_SR      uint32 = 0x1B00 // 格式RR减法（32）
	op_SRA     uint32 = 0x8A00 // 格式RS1右移单（32）
	op_SRAG    uint32 = 0xEB0A // 格式RSY1右移单（64）
	op_SRAK    uint32 = 0xEBDC // 格式RSY1右移单（32）
	op_SRDA    uint32 = 0x8E00 // 格式RS1右移双
	op_SRDL    uint32 = 0x8C00 // 格式RS1右移双逻辑
	op_SRDT    uint32 = 0xED41 // 格式RXF有效位右移（长DFP）
	op_SRK     uint32 = 0xB9F9 // 格式RRF1减法（32）
	op_SRL     uint32 = 0x8800 // 格式RS1右移单逻辑（32）
	op_SRLG    uint32 = 0xEB0C // 格式RSY1右移单逻辑（64）
	op_SRLK    uint32 = 0xEBDE // 格式RSY1右移单逻辑（32）
	op_SRNM    uint32 = 0xB299 // 格式设置BFP舍入模式（2位）
	op_SRNMB   uint32 = 0xB2B8 // 格式设置BFP舍入模式（3位）
	op_SRNMT   uint32 = 0xB2B9 // 格式设置DFP舍入模式
	op_SRP     uint32 = 0xF000 // 格式SS3移位和十进制
	op_SRST    uint32 = 0xB25E // 格式搜索字符串
	op_SRSTU   uint32 = 0xB9BE // 格式搜索字符串UNICODE 
	op_SRXT    uint32 = 0xED49 // 格式RXF移位有效位右（扩展DFP）
	op_SSAIR   uint32 = 0xB99F // 格式化设置辅助ASN与实例
	op_SSAR    uint32 = 0xB225 // 格式化设置辅助ASN 
	op_SSCH    uint32 = 0xB233 // 格式化启动子通道
	op_SSKE    uint32 = 0xB22B // 格式化设置存储密钥扩展
	op_SSM     uint32 = 0x8000 // 格式化设置系统掩码
	op_ST      uint32 = 0x5000 // 格式化设置RX1存储（32）
	op_STAM    uint32 = 0x9B00 // 格式RS1存储访问多个
	op_STAMY   uint32 = 0xEB9B // 格式RSY1存储访问多个
	op_STAP    uint32 = 0xB212 // 格式RS1存储CPU地址
	op_STC     uint32 = 0x4200 // 格式RX1存储字符
	op_STCH    uint32 = 0xE3C3 // 格式RXY1存储字符高（8）
	op_STCK    uint32 = 0xB205 // 格式存储时钟
	op_STCKC   uint32 = 0xB207 // 格式存储时钟比较器
	op_STCKE   uint32 = 0xB278 // 格式化存储时钟扩展
	op_STCKF   uint32 = 0xB27C // 格式化存储时钟快速
	op_STCM    uint32 = 0xBE00 // 格式化存储掩码下字符（低）
	op_STCMH   uint32 = 0xEB2C // 格式化存储掩码下字符（高）
	op_STCMY   uint32 = 0xEB2D // FORMAT_RSY2存储掩码下字符（低）
	op_STCPS   uint32 = 0xB23A // FORMAT_RSY2存储通道路径状态
	op_STCRW   uint32 = 0xB239 // FORMAT_S存储通道报告字
	op_STCTG   uint32 = 0xEB25 // FORMAT_RSY1存储控件（64）
	op_STCTL   uint32 = 0xB600 // FORMAT_RS1存储控件（32）
	op_STCY    uint32 = 0xE372 // FORMAT_RXY1存储字符
	op_STD     uint32 = 0x6000 // 格式RX1存储（长）
	op_STDY    uint32 = 0xED67 // 格式RXY1存储（长）
	op_STE     uint32 = 0x7000 // 格式RX1存储（短）
	op_STEY    uint32 = 0xED66 // 格式RXY1存储（短）
	op_STFH    uint32 = 0xE3CB // 格式RXY1存储高（32）
	op_STFL    uint32 = 0xB2B1 // 格式商店设施清单
	op_STFLE   uint32 = 0xB2B0 // 格式商店设施清单扩展
	op_STFPC   uint32 = 0xB29C // 格式存储FPC 
	op_STG     uint32 = 0xE324 // 格式存储（64）
	op_STGRL   uint32 = 0xC40B // 格式存储相对长（64）
	op_STH     uint32 = 0x4000 // 格式存储半字
	op_STHH    uint32 = 0xE3C7 // 格式存储半字高（16）
	op_STHRL   uint32 = 0xC407 // 格式存储半字相对长
	op_STIDP   uint32 = 0xB202 // 格式化存储CPU ID 
	op_STM     uint32 = 0x9000 // 格式化RS1存储多个（32）
	op_STMG    uint32 = 0xEB24 // 格式化RSY1存储多个（64）
	op_STMH    uint32 = 0xEB26 // 格式化RSY1存储多个高
	op_STMY    uint32 = 0xEB90 // 格式化RSY1存储多个（32）
	op_STNSM   uint32 = 0xAC00 // 格式化RSY1存储和系统掩码
	op_STOCG   uint32 = 0xEBE3 // FORMAT_RSY2 STORE ON CONDITION（64）
	op_STOSM   uint32 = 0xAD00 // FORMAT_RSY2 STORE THEN或系统掩码
	op_STPQ    uint32 = 0xE38E // FORMAT_RXY1 STORE对到四字
	op_STPT    uint32 = 0xB209 // FORMAT_S STORE CPU定时器
	op_STPX    uint32 = 0xB211 // FORMAT_S STORE前缀
	op_STRAG   uint32 = 0xE502 // FORMAT_SSE STORE实际地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址
	op_STURG   uint32 = 0xB925 // 格式化使用实地址的RRE存储（64）
	op_STY     uint32 = 0xE350 // 格式化使用实地址的RRE存储（32）
	op_SU      uint32 = 0x7F00 // 格式化用RX1减去非规范化（短HFP）
	op_SW      uint32 = 0x6F00 // 格式RX1减法非规范化（长HFP）
	op_SWR     uint32 = 0x2F00 // 格式RR减法非规范化（长HFP）
	op_SXBR    uint32 = 0xB34B // 格式RRE减法（扩展BFP）
	op_SXR     uint32 = 0x3700 // 格式RR减法规范化（扩展HFP）
	op_SY      uint32 = 0xE35B // FORMAT_RXY1 SUBTRACT（32）
	op_TABORT  uint32 = 0xB2FC // FORMAT_S事务中止
	op_TAM     uint32 = 0x010B // FORMAT_E测试寻址模式
	op_TAR     uint32 = 0xB24C // FORMAT_RRE测试访问
	op_TB      uint32 = 0xB22C // FORMAT_RRE测试块
	op_TBDR    uint32 = 0xB351 // FORMAT_RRF5将HFP转换为BFP（长）
	op_TBEGIN  uint32 = 0xE560 // FORMAT_SIL事务开始
	op_TBEGINC uint32 = 0xE561 // FORMAT_SIL事务开始
	op_TCDB    uint32 = 0xED11 // FORMAT_RXE测试数据类（长BFP）
	op_TCEB    uint32 = 0xED10 // FORMAT_RXE测试数据类（短BFP）
	op_TCXB    uint32 = 0xED12 // FORMATMAT_RXE测试数据类（扩展BFP）
	op_TDCDT   uint32 = 0xED54 // 格式RXE测试数据类（长DFP）
	op_TDCET   uint32 = 0xED50 // 格式RXE测试数据类（短DFP）
	op_TDCXT   uint32 = 0xED58 // 格式RXE测试数据类（扩展DFP）
	op_TDGDT   uint32 = 0xED55 // 格式RXE测试数据组（长DFP）
	op_TDGET   uint32 = 0xED51 // 格式RXE测试数据组（短DFP）
	op_TDGXT   uint32 = 0xED59 // 格式RXE测试数据组（扩展DFP）
	op_TEND    uint32 = 0xB2F8 // 格式事务结束
	op_THDER   uint32 = 0xB358 // 格式将BFP转换为HFP（从短到长）
	op_THDR    uint32 = 0xB359 // 格式将BFP转换为HFP（长）
	op_TM      uint32 = 0x9100 // 格式在掩码下进行SI测试
	op_TMH     uint32 = 0xA700 // 格式在掩码下进行RI1测试高
	op_TMHH    uint32 = 0xA702 // 格式在掩码下进行RI1测试（高-高）
	op_TMHL    uint32 = 0xA703 // FORMAT_RI1 MASK下测试（高-低）
	op_TML     uint32 = 0xA701 // FORMAT_RI1 MASK下测试（低-低）
	op_TMLH    uint32 = 0xA700 // FORMAT_RI1 MASK下测试（低-低）
	op_TMY     uint32 = 0xEB51 // FORMAT_-SIY TEST UNDER MASK 
	op_TP      uint32 = 0xEBC0 // FORMAT_-RSL TEST DECIMAL 
	op_TPI     uint32 = 0xB236 // FORMAT_-S TEST PENDING INTERRUPTION 
	op_TPROT   uint32 = 0xE501 // FORMAT_-SSE TEST PROTECTION 
	op_TR      uint32 = 0xDC00 // FORMAT_-SS1 TRANSLATE 
	op_TRACE   uint32 = 0x9900 // FORMAT_-RS1 TRACE（32）
	op_TRACG   uint32 = 0xEB0F // FORMAT_-RSY1 TRACE（64）
	op_TRAP2   uint32 = 0x01FF // 格式\u E TRAP 
	op_TRAP4   uint32 = 0xB2FF // 格式\u S TRAP 
	op_TRE     uint32 = 0xB2A5 // 格式\u RRF3翻译扩展
	op_TROO    uint32 = 0xB993 // 格式\u RRF3翻译一对一
	op_TROT    uint32 = 0xB992 // 格式\u RRF3翻译一对二
	op_TRT     uint32 = 0xDD00 // 格式\u SS1翻译和测试
	op_TRTE    uint32 = 0xB9BF // 格式\u RRF3翻译和测试扩展
	op_TRTO    uint32 = 0xB991 // 格式RRF3翻译二到一
	op_TRTR    uint32 = 0xD000 // 格式SS1翻译和测试反向
	op_TRTRE   uint32 = 0xB9BD // 格式RRF3翻译和测试反向扩展
	op_TRTT    uint32 = 0xB990 // 格式RRF3翻译二到二
	op_TS      uint32 = 0x9300 // 格式S测试和设置
	op_TSCH    uint32 = 0xB235 // 格式S测试子通道
	op_UNPK    uint32 = 0xF300 // 格式SS2解包
	op_UNPKA   uint32 = 0xEA00 // 格式SS1解包ASCII 
	op_UNPKU   uint32 = 0xE200 // 格式SS1解包UNICODE 
	op_UPT     uint32 = 0x0102 // 格式更新树
	op_X       uint32 = 0x5700 // 格式RX1独占或（32）
	op_XC      uint32 = 0xD700 // 格式SS1独占或（字符）
	op_XG      uint32 = 0xE382 // 格式RXY1独占或（64）
	op_XGR     uint32 = 0xB982 // FORMAT_-RRE EXCLUSIVE OR（64）
	op_XR      uint32 = 0x1700 // FORMAT_RR EXCLUSIVE OR（32）
	op_XRK     uint32 = 0xB9F7 // FORMAT_RRF1 EXCLUSIVE OR（32）
	op_XSCH    uint32 = 0xB276 // FORMAT_S CANCEL SUBCHANNEL 
	op_XY      uint32 = 0xE357 // FORMAT_RXY1 EXCLUSIVE OR（32）
	op_ZAP     uint32 = 0xF800 // FORMAT_SS2 ZERO AND ADD 

	// 添加到z13 
	op_CXPT   uint32 = 0xEDAF // RSL-b从压缩（到扩展DFP）
	op_CDPT   uint32 = 0xEDAE // RSL-b从压缩（到长DFP）转换
	op_CPXT   uint32 = 0xEDAD // RSL-b转换到压缩（从扩展DFP）
	op_CPDT   uint32 = 0xEDAC // RSL-b转换到压缩（从长DFP）
	op_LZRF   uint32 = 0xE33B // RXY-a加载和最右零字节（32）
	op_LZRG   uint32 = 0xE32A // RXY a加载和最右零字节（64）
	op_LCCB   uint32 = 0xE727 // RXE加载计数到块边界
	op_LOCHI  uint32 = 0xEC42 // RIE-g在条件（32）下立即加载半字←16） 
	op_LOCGHI uint32 = 0xEC46 // RIE-g在条件（64）下立即加载半字←16） 
	op_LOCFH  uint32 = 0xEBE0 // RSY-b在条件（32）下加载高电平（32）
	op_LOCFHR uint32 = 0xB9E0 // RRF-c在条件（32）下加载高电平（32）
	op_LLZRGF uint32 = 0xE33A // RXY-a加载逻辑和最右边的零字节（64←32）
	op_STOCFH uint32 = 0xEBE1 // RSY-b高存储条件
	op_VA     uint32 = 0xE7F3 // VRR-c矢量添加
	op_VACC   uint32 = 0xE7F1 // VRR-c矢量添加计算进位
	op_VAC    uint32 = 0xE7BB // VRR-d矢量添加进位
	op_VACCC  uint32 = 0xE7B9 // VRR-d矢量添加进位计算进位
	op_VN     uint32 = 0xE768 // VRR-c矢量和
	op_VNC    uint32 = 0xE769 // VRR-c矢量和补码
	op_VAVG   uint32 = 0xE7F2 // VRR-c向量平均
	op_VAVGL  uint32 = 0xE7F0 // VRR-c向量平均逻辑
	op_VCKSM  uint32 = 0xE766 // VRR-c向量校验和
	op_VCEQ   uint32 = 0xE7F8 // VRR-b向量比较相等
	op_VCH    uint32 = 0xE7FB // VRR-b向量比较高
	op_VCHL   uint32 = 0xE7F9 // VRR-b向量比较高逻辑
	op_VCLZ   uint32 = 0xE753 // VRR-a向量计数前导零
	op_VCTZ   uint32 = 0xE752 // VRR-a向量计数尾随零
	op_VEC    uint32 = 0xE7DB // VRR-a矢量元素比较
	op_VECL   uint32 = 0xE7D9 // VRR-a矢量元素比较逻辑
	op_VERIM  uint32 = 0xE772 // VRI-d矢量元素旋转并在掩码下插入
	op_VERLL  uint32 = 0xE733 // VRS-a矢量元素旋转左逻辑
	op_VERLLV uint32 = 0xE773 // VRR-c矢量元素旋转左逻辑
	op_VESLV  uint32 = 0xE770 // VRR-c矢量元素左移位
	op_VESL   uint32 = 0xE730 // /VRS-a矢量元素左移
	op_VESRA  uint32 = 0xE73A // VRS-a矢量元素右移算法
	op_VESRAV uint32 = 0xE77A // VRR-c矢量元素右移算法
	op_VESRL  uint32 = 0xE738 // VRS-a矢量元素右移逻辑
	op_VESRLV uint32 = 0xE778 // VRR-c矢量元素右移逻辑
	op_VX     uint32 = 0xE76D // VRR-c矢量异或
	op_VFAE   uint32 = 0xE782 // VRR-b矢量查找任何元素相等
	op_VFEE   uint32 = 0xE780 // VRR-b向量查找元素相等
	op_VFENE  uint32 = 0xE781 // VRR-b向量查找元素不相等
	op_VFA    uint32 = 0xE7E3 // VRR-c向量FP添加
	op_WFK    uint32 = 0xE7CA // VRR-a向量FP比较和信号标量
	op_VFCE   uint32 = 0xE7E8 // VRR-c向量FP比较相等
	op_VFCH   uint32 = 0xE7EB // VRR-c向量FP比较高
	op_VFCHE  uint32 = 0xE7EA // VRR-c向量FP比较高或相等
	op_WFC    uint32 = 0xE7CB // VRR-a向量FP比较标量
	op_VCDG   uint32 = 0xE7C3 // VRR-a向量FP转换自固定64位
	op_VCDLG  uint32 = 0xE7C1 // VRR-a向量FP转换自逻辑64位
	op_VCGD   uint32 = 0xE7C2 // VRR-a向量FP转换至固定64位
	op_VCLGD  uint32 = 0xE7C0 // VRR-a向量FP转换为逻辑64位
	op_VFD    uint32 = 0xE7E5 // VRR-c矢量FP除以
	op_VLDE   uint32 = 0xE7C4 // VRR-a矢量FP加载加长
	op_VLED   uint32 = 0xE7C5 // VRR-a矢量FP加载四舍五入
	op_VFM    uint32 = 0xE7E7 // VRR-c矢量FP乘
	op_VFMA   uint32 = 0xE78F // VRR-e矢量FP乘加
	op_VFMS   uint32 = 0xE78E // VRR-e矢量FP乘减
	op_VFPSO  uint32 = 0xE7CC // VRR-a矢量FP符号运算
	op_VFSQ   uint32 = 0xE7CE // VRR-a向量FP平方根
	op_VFS    uint32 = 0xE7E2 // VRR-c向量FP减法
	op_VFTCI  uint32 = 0xE74A // VRI-e向量FP测试数据类立即
	op_VGFM   uint32 = 0xE7B4 // VRR-c向量伽罗瓦域乘和
	op_VGFMA  uint32 = 0xE7BC // VRR-d向量伽罗瓦域乘和和累加
	op_VGEF   uint32 = 0xE713 // VRV向量聚集元素（32）
	op_VGEG   uint32 = 0xE712 // VRV向量集合元素（64）
	op_VGBM   uint32 = 0xE744 // VRI-a向量生成字节掩码
	op_VGM    uint32 = 0xE746 // VRI-b向量生成掩码
	op_VISTR  uint32 = 0xE75C // VRR-a向量隔离字符串
	op_VL     uint32 = 0xE706 // VRX向量加载
	op_VLR    uint32 = 0xE756 // VRR-a向量加载
	op_VLREP  uint32 = 0xE705 // VRX向量加载和复制
	op_VLC    uint32 = 0xE7DE // VRR-a向量加载补充
	op_VLEH   uint32 = 0xE701 // VRX矢量加载元件（16）
	op_VLEF   uint32 = 0xE703 // VRX矢量加载元件（32）
	op_VLEG   uint32 = 0xE702 // VRX矢量加载元件（64）
	op_VLEB   uint32 = 0xE700 // VRX矢量加载元件（8）
	op_VLEIH  uint32 = 0xE741 // VRI-a矢量加载元件立即（16）
	op_VLEIF  uint32 = 0xE743 // VRI-a矢量加载元件立即（32）
	op_VLEIG  uint32 = 0xE742 // VRI-a矢量加载元件立即（64）
	op_VLEIB  uint32 = 0xE740 // VRI-a矢量加载元素立即数（8）
	op_VFI    uint32 = 0xE7C7 // VRR-a矢量加载FP整数
	op_VLGV   uint32 = 0xE721 // VRS-c矢量加载GR来自VR元素
	op_VLLEZ  uint32 = 0xE704 // VRX矢量加载逻辑元素和零
	op_VLM    uint32 = 0xE736 // VRS-a矢量加载多个
	op_VLP    uint32 = 0xE7DF // VRR-a矢量加载正
	op_VLBB   uint32 = 0xE707 // VRX矢量加载到块边界
	op_VLVG   uint32 = 0xE722 // VRS-b矢量加载VR元素来自GR 
	op_VLVGP  uint32 = 0xE762 // VRR-f矢量加载VR来自GRS不相交
	op_VLL    uint32 = 0xE737 // VRS-b矢量加载长度
	op_VMX    uint32 = 0xE7FF // VRR-c矢量最大
	op_VMXL   uint32 = 0xE7FD // VRR-c矢量最大逻辑
	op_VMRH   uint32 = 0xE761 // VRR-c矢量合并高
	op_VMRL   uint32 = 0xE760 // VRR-c矢量合并低
	op_VMN    uint32 = 0xE7FE // VRR-c向量最小
	op_VMNL   uint32 = 0xE7FC // VRR-c向量最小逻辑
	op_VMAE   uint32 = 0xE7AE // VRR-d向量乘和加偶数
	op_VMAH   uint32 = 0xE7AB // VRR-d向量乘和加高
	op_VMALE  uint32 = 0xE7AC // VRR-d向量乘和加逻辑偶数
	op_VMALH  uint32 = 0xE7A9 // VRR-d向量乘和加逻辑高
	op_VMALO  uint32 = 0xE7AD // VRR-d向量乘和加逻辑奇数
	op_VMAL   uint32 = 0xE7AA // VRR-d向量乘和加低
	op_VMAO   uint32 = 0xE7AF // VRR-d向量乘和加奇数
	op_VME    uint32 = 0xE7A6 // VRR-c向量乘偶数
	op_VMH    uint32 = 0xE7A3 // VRR-c向量乘高
	op_VMLE   uint32 = 0xE7A4 // VRR-c向量乘偶数逻辑
	op_VMLH   uint32 = 0xE7A1 // VRR-c向量乘高逻辑
	op_VMLO   uint32 = 0xE7A5 // VRR-c向量乘奇数逻辑
	op_VML    uint32 = 0xE7A2 // VRR-c向量乘低
	op_VMO    uint32 = 0xE7A7 // VRR-c向量乘奇数
	op_VNO    uint32 = 0xE76B // VRR-c向量或
	op_VO     uint32 = 0xE76A // VRR-c向量或
	op_VPK    uint32 = 0xE794 // VRR-c向量组
	op_VPKLS  uint32 = 0xE795 // VRR-b向量组逻辑饱和
	op_VPKS   uint32 = 0xE797 // VRR-b向量组饱和
	op_VPERM  uint32 = 0xE78C // VRR-e向量组置换
	op_VPDI   uint32 = 0xE784 // VRR-c向量置换双字立即
	op_VPOPCT uint32 = 0xE750 // VRR-a向量总体计数
	op_VREP   uint32 = 0xE74D // VRI-c向量复制
	op_VREPI  uint32 = 0xE745 // VRI-a向量复制立即
	op_VSCEF  uint32 = 0xE71B // VRV向量分散元素（32）
	op_VSCEG  uint32 = 0xE71A // VRV向量分散元素（64）
	op_VSEL   uint32 = 0xE78D // VRR-e向量选择
	op_VSL    uint32 = 0xE774 // VRR-c矢量左移
	op_VSLB   uint32 = 0xE775 // VRR-c矢量字节左移
	op_VSLDB  uint32 = 0xE777 // VRI-d矢量字节左移双字节
	op_VSRA   uint32 = 0xE77E // VRR-c矢量右移算法
	op_VSRAB  uint32 = 0xE77F // VRR-c矢量字节右移算法
	op_VSRL   uint32 = 0xE77C // VRR-c矢量字节右移逻辑
	op_VSRLB  uint32 = 0xE77D // VRR-c矢量字节右移逻辑
	op_VSEG   uint32 = 0xE75F // VRR-a矢量符号扩展到双字
	op_VST    uint32 = 0xE70E // VRX矢量存储
	op_VSTEH  uint32 = 0xE709 // VRX矢量存储元素（16）
	op_VSTEF  uint32 = 0xE70B // VRX矢量存储元素（32）
	op_VSTEG  uint32 = 0xE70A // VRX矢量存储元素（64）
	op_VSTEB  uint32 = 0xE708 // VRX矢量存储元素（8）
	op_VSTM   uint32 = 0xE73E // VRS-a矢量存储多个
	op_VSTL   uint32 = 0xE73F // VRS-b矢量存储长度
	op_VSTRC  uint32 = 0xE78A // VRR-d矢量字符串范围比较
	op_VS     uint32 = 0xE7F7 // VRR-c矢量减去
	op_VSCBI  uint32 = 0xE7F5 // VRR-c矢量减去计算借用指示
	op_VSBCBI uint32 = 0xE7BD // VRR-d矢量减去计算借用借用指示
	op_VSBI   uint32 = 0xE7BF // VRR-d向量减去借用指示
	op_VSUMG  uint32 = 0xE765 // VRR-c双字向量和
	op_VSUMQ  uint32 = 0xE767 // VRR-c四字向量和
	op_VSUM   uint32 = 0xE764 // VRR-c字向量和
	op_VTM    uint32 = 0xE7D8 // VRR-a掩码下向量测试
	op_VUPH   uint32 = 0xE7D7 // VRR-a向量解压高
	op_VUPLH  uint32 = 0xE7D5 // VRR-a向量解压逻辑高位
	op_VUPLL  uint32 = 0xE7D4 // VRR-a向量解压逻辑低位
	op_VUPL   uint32 = 0xE7D6 // VRR-a向量解压低位
	op_VMSL   uint32 = 0xE7B8 // VRR-d向量乘和逻辑
)

func oclass(a *obj.Addr) int {
	return int(a.Class) - 1
}

// 在RIL指令中为立即数添加重定位。
// 加数将根据需要进行调整。
func (c *ctxtz) addrilreloc(sym *obj.LSym, add int64) *obj.Reloc {
	if sym == nil {
		c.ctxt.Diag("require symbol to apply relocation")
	}
	offset := int64(2) // 从指令开始的重定位偏移量
	rel := obj.Addrel(c.cursym)
	rel.Off = int32(c.pc + offset)
	rel.Siz = 4
	rel.Sym = sym
	rel.Add = add + offset + int64(rel.Siz)
	rel.Type = objabi.R_PCRELDBL
	return rel
}

func (c *ctxtz) addrilrelocoffset(sym *obj.LSym, add, offset int64) *obj.Reloc {
	if sym == nil {
		c.ctxt.Diag("require symbol to apply relocation")
	}
	offset += int64(2) // 从指令开始的重定位偏移量
	rel := obj.Addrel(c.cursym)
	rel.Off = int32(c.pc + offset)
	rel.Siz = 4
	rel.Sym = sym
	rel.Add = add + offset + int64(rel.Siz)
	rel.Type = objabi.R_PCRELDBL
	return rel
}

// 在RIL风格的指令中为立即数添加调用重定位。
// 加数将根据需要进行调整。
func (c *ctxtz) addcallreloc(sym *obj.LSym, add int64) *obj.Reloc {
	if sym == nil {
		c.ctxt.Diag("require symbol to apply relocation")
	}
	offset := int64(2) // 从指令开始的重新定位偏移量
	rel := obj.Addrel(c.cursym)
	rel.Off = int32(c.pc + offset)
	rel.Siz = 4
	rel.Sym = sym
	rel.Add = add + offset + int64(rel.Siz)
	rel.Type = objabi.R_CALL
	return rel
}

func (c *ctxtz) branchMask(p *obj.Prog) CCMask {
	switch p.As {
	case ABRC, ALOCR, ALOCGR,
		ACRJ, ACGRJ, ACIJ, ACGIJ,
		ACLRJ, ACLGRJ, ACLIJ, ACLGIJ:
		return CCMask(p.From.Offset)
	case ABEQ, ACMPBEQ, ACMPUBEQ, AMOVDEQ:
		return Equal
	case ABGE, ACMPBGE, ACMPUBGE, AMOVDGE:
		return GreaterOrEqual
	case ABGT, ACMPBGT, ACMPUBGT, AMOVDGT:
		return Greater
	case ABLE, ACMPBLE, ACMPUBLE, AMOVDLE:
		return LessOrEqual
	case ABLT, ACMPBLT, ACMPUBLT, AMOVDLT:
		return Less
	case ABNE, ACMPBNE, ACMPUBNE, AMOVDNE:
		return NotEqual
	case ABLEU: // LE或无序
		return NotGreater
	case ABLTU: // LT或无序
		return LessOrUnordered
	case ABVC:
		return Never // 需要额外指令
	case ABVS:
		return Unordered
	}
	c.ctxt.Diag("unknown conditional branch %v", p.As)
	return Always
}

func regtmp(p *obj.Prog) uint32 {
	p.Mark |= USETMP
	return REGTMP
}

func (c *ctxtz) asmout(p *obj.Prog, asm *[]byte) {
	o := c.oplook(p)

	if o == nil {
		return
	}

	// 如果在生成的代码中使用REGTMP，我们需要在p.Mark上设置USETMP。
	// 所以我们使用regtmp（p）来表示regtmp。

	switch o.i {
	default:
		c.ctxt.Diag("unknown index %d", o.i)

	case 0: // 伪运算
		break

	case 1: // mov reg reg 
		switch p.As {
		default:
			c.ctxt.Diag("unhandled operation: %v", p.As)
		case AMOVD:
			zRRE(op_LGR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
		// 符号扩展
		case AMOVW:
			zRRE(op_LGFR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
		case AMOVH:
			zRRE(op_LGHR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
		case AMOVB:
			zRRE(op_LGBR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
		// 零扩展
		case AMOVWZ:
			zRRE(op_LLGFR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
		case AMOVHZ:
			zRRE(op_LLGHR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
		case AMOVBZ:
			zRRE(op_LLGCR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
		// 反向字节
		case AMOVDBR:
			zRRE(op_LRVGR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
		case AMOVWBR:
			zRRE(op_LRVR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
		// 浮点
		case AFMOVD, AFMOVS:
			zRR(op_LDR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
		}

	case 2: // 算术运算reg[reg]reg 
		r := p.Reg
		if r == 0 {
			r = p.To.Reg
		}

		var opcode uint32

		switch p.As {
		default:
			c.ctxt.Diag("invalid opcode")
		case AADD:
			opcode = op_AGRK
		case AADDC:
			opcode = op_ALGRK
		case AADDE:
			opcode = op_ALCGR
		case AADDW:
			opcode = op_ARK
		case AMULLW:
			opcode = op_MSGFR
		case AMULLD:
			opcode = op_MSGR
		case ADIVW, AMODW:
			opcode = op_DSGFR
		case ADIVWU, AMODWU:
			opcode = op_DLR
		case ADIVD, AMODD:
			opcode = op_DSGR
		case ADIVDU, AMODDU:
			opcode = op_DLGR
		}

		switch p.As {
		default:

		case AADD, AADDC, AADDW:
			if p.As == AADDW && r == p.To.Reg {
				zRR(op_AR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
			} else {
				zRRF(opcode, uint32(p.From.Reg), 0, uint32(p.To.Reg), uint32(r), asm)
			}

		case AADDE, AMULLW, AMULLD:
			if r == p.To.Reg {
				zRRE(opcode, uint32(p.To.Reg), uint32(p.From.Reg), asm)
			} else if p.From.Reg == p.To.Reg {
				zRRE(opcode, uint32(p.To.Reg), uint32(r), asm)
			} else {
				zRRE(op_LGR, uint32(p.To.Reg), uint32(r), asm)
				zRRE(opcode, uint32(p.To.Reg), uint32(p.From.Reg), asm)
			}

		case ADIVW, ADIVWU, ADIVD, ADIVDU:
			if p.As == ADIVWU || p.As == ADIVDU {
				zRI(op_LGHI, regtmp(p), 0, asm)
			}
			zRRE(op_LGR, REGTMP2, uint32(r), asm)
			zRRE(opcode, regtmp(p), uint32(p.From.Reg), asm)
			zRRE(op_LGR, uint32(p.To.Reg), REGTMP2, asm)

		case AMODW, AMODWU, AMODD, AMODDU:
			if p.As == AMODWU || p.As == AMODDU {
				zRI(op_LGHI, regtmp(p), 0, asm)
			}
			zRRE(op_LGR, REGTMP2, uint32(r), asm)
			zRRE(opcode, regtmp(p), uint32(p.From.Reg), asm)
			zRRE(op_LGR, uint32(p.To.Reg), regtmp(p), asm)

		}

		v := c.vregoff(&p.From)
		switch p.As {
		case AMOVBZ:
			v = int64(uint8(v))
		case AMOVHZ:
			v = int64(uint16(v))
		case AMOVWZ:
			v = int64(uint32(v))
		case AMOVB:
			v = int64(int8(v))
		case AMOVH:
			v = int64(int16(v))
		case AMOVW:
			v = int64(int32(v))
		}
		if int64(int16(v)) == v {
			zRI(op_LGHI, uint32(p.To.Reg), uint32(v), asm)
		} else if v&0xffff0000 == v {
			zRI(op_LLILH, uint32(p.To.Reg), uint32(v>>16), asm)
		} else if v&0xffff00000000 == v {
			zRI(op_LLIHL, uint32(p.To.Reg), uint32(v>>32), asm)
		} else if uint64(v)&0xffff000000000000 == uint64(v) {
			zRI(op_LLIHH, uint32(p.To.Reg), uint32(v>>48), asm)
		} else if int64(int32(v)) == v {
			zRIL(_a, op_LGFI, uint32(p.To.Reg), uint32(v), asm)
		} else if int64(uint32(v)) == v {
			zRIL(_a, op_LLILF, uint32(p.To.Reg), uint32(v), asm)
		} else if uint64(v)&0xffffffff00000000 == uint64(v) {
			zRIL(_a, op_LLIHF, uint32(p.To.Reg), uint32(v>>32), asm)
		} else {
			zRIL(_a, op_LLILF, uint32(p.To.Reg), uint32(v), asm)
			zRIL(_a, op_IIHF, uint32(p.To.Reg), uint32(v>>32), asm)
		}

	case 4: // 乘法high（a*b）>>64 
		r := p.Reg
		if r == 0 {
			r = p.To.Reg
		}
		zRRE(op_LGR, REGTMP2, uint32(r), asm)
		zRRE(op_MLGR, regtmp(p), uint32(p.From.Reg), asm)
		switch p.As {
		case AMULHDU:
			// 无符号：移动结果输入正确的寄存器。
			zRRE(op_LGR, uint32(p.To.Reg), regtmp(p), asm)
		case AMULHD:
			// 已签名：需要转换结果。
			// 见黑客之乐8-3。
			zRSY(op_SRAG, REGTMP2, uint32(p.From.Reg), 0, 63, asm)
			zRRE(op_NGR, REGTMP2, uint32(r), asm)
			zRRE(op_SGR, regtmp(p), REGTMP2, asm)
			zRSY(op_SRAG, REGTMP2, uint32(r), 0, 63, asm)
			zRRE(op_NGR, REGTMP2, uint32(p.From.Reg), asm)
			zRRF(op_SGRK, REGTMP2, 0, uint32(p.To.Reg), regtmp(p), asm)
		}

	case 5: // 系统调用
		zI(op_SVC, 0, asm)

	case 6: // 逻辑运算寄存器[reg]寄存器
		var oprr, oprre, oprrf uint32
		switch p.As {
		case AAND:
			oprre = op_NGR
			oprrf = op_NGRK
		case AANDW:
			oprr = op_NR
			oprrf = op_NRK
		case AOR:
			oprre = op_OGR
			oprrf = op_OGRK
		case AORW:
			oprr = op_OR
			oprrf = op_ORK
		case AXOR:
			oprre = op_XGR
			oprrf = op_XGRK
		case AXORW:
			oprr = op_XR
			oprrf = op_XRK
		}
		if p.Reg == 0 {
			if oprr != 0 {
				zRR(oprr, uint32(p.To.Reg), uint32(p.From.Reg), asm)
			} else {
				zRRE(oprre, uint32(p.To.Reg), uint32(p.From.Reg), asm)
			}
		} else {
			zRRF(oprrf, uint32(p.Reg), 0, uint32(p.To.Reg), uint32(p.From.Reg), asm)
		}

	case 7: // 移位/旋转寄存器[reg]寄存器
		d2 := c.vregoff(&p.From)
		b2 := p.From.Reg
		r3 := p.Reg
		if r3 == 0 {
			r3 = p.To.Reg
		}
		r1 := p.To.Reg
		var opcode uint32
		switch p.As {
		default:
		case ASLD:
			opcode = op_SLLG
		case ASRD:
			opcode = op_SRLG
		case ASLW:
			opcode = op_SLLK
		case ASRW:
			opcode = op_SRLK
		case ARLL:
			opcode = op_RLL
		case ARLLG:
			opcode = op_RLLG
		case ASRAW:
			opcode = op_SRAK
		case ASRAD:
			opcode = op_SRAG
		}
		zRSY(opcode, uint32(r1), uint32(r3), uint32(b2), uint32(d2), asm)

	case 8: // 查找最左边的一个
		if p.To.Reg&1 != 0 {
			c.ctxt.Diag("target must be an even-numbered register")
		}
		// FLOGR还向p.to写入掩码。注册+1。
		zRRE(op_FLOGR, uint32(p.To.Reg), uint32(p.From.Reg), asm)

	case 9: // 人口计数
		zRRE(op_POPCNT, uint32(p.To.Reg), uint32(p.From.Reg), asm)

	case 10: // 减去reg[reg]reg 
		r := int(p.Reg)

		switch p.As {
		default:
		case ASUB:
			if r == 0 {
				zRRE(op_SGR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
			} else {
				zRRF(op_SGRK, uint32(p.From.Reg), 0, uint32(p.To.Reg), uint32(r), asm)
			}
		case ASUBC:
			if r == 0 {
				zRRE(op_SLGR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
			} else {
				zRRF(op_SLGRK, uint32(p.From.Reg), 0, uint32(p.To.Reg), uint32(r), asm)
			}
		case ASUBE:
			if r == 0 {
				r = int(p.To.Reg)
			}
			if r == int(p.To.Reg) {
				zRRE(op_SLBGR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
			} else if p.From.Reg == p.To.Reg {
				zRRE(op_LGR, regtmp(p), uint32(p.From.Reg), asm)
				zRRE(op_LGR, uint32(p.To.Reg), uint32(r), asm)
				zRRE(op_SLBGR, uint32(p.To.Reg), regtmp(p), asm)
			} else {
				zRRE(op_LGR, uint32(p.To.Reg), uint32(r), asm)
				zRRE(op_SLBGR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
			}
		case ASUBW:
			if r == 0 {
				zRR(op_SR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
			} else {
				zRRF(op_SRK, uint32(p.From.Reg), 0, uint32(p.To.Reg), uint32(r), asm)
			}
		}

	case 11: // br/bl 
		v := int32(0)

		if p.To.Target() != nil {
			v = int32((p.To.Target().Pc - p.Pc) >> 1)
		}

		if p.As == ABR && p.To.Sym == nil && int32(int16(v)) == v {
			zRI(op_BRC, 0xF, uint32(v), asm)
		} else {
			if p.As == ABL {
				zRIL(_b, op_BRASL, uint32(REG_LR), uint32(v), asm)
			} else {
				zRIL(_c, op_BRCL, 0xF, uint32(v), asm)
			}
			if p.To.Sym != nil {
				c.addcallreloc(p.To.Sym, p.To.Offset)
			}
		}

	case 12:
		r1 := p.To.Reg
		d2 := c.vregoff(&p.From)
		b2 := p.From.Reg
		if b2 == 0 {
			b2 = REGSP
		}
		x2 := p.From.Index
		if -DISP20/2 > d2 || d2 >= DISP20/2 {
			zRIL(_a, op_LGFI, regtmp(p), uint32(d2), asm)
			if x2 != 0 {
				zRX(op_LA, regtmp(p), regtmp(p), uint32(x2), 0, asm)
			}
			x2 = int16(regtmp(p))
			d2 = 0
		}
		var opx, opxy uint32
		switch p.As {
		case AADD:
			opxy = op_AG
		case AADDC:
			opxy = op_ALG
		case AADDE:
			opxy = op_ALCG
		case AADDW:
			opx = op_A
			opxy = op_AY
		case AMULLW:
			opx = op_MS
			opxy = op_MSY
		case AMULLD:
			opxy = op_MSG
		case ASUB:
			opxy = op_SG
		case ASUBC:
			opxy = op_SLG
		case ASUBE:
			opxy = op_SLBG
		case ASUBW:
			opx = op_S
			opxy = op_SY
		case AAND:
			opxy = op_NG
		case AANDW:
			opx = op_N
			opxy = op_NY
		case AOR:
			opxy = op_OG
		case AORW:
			opx = op_O
			opxy = op_OY
		case AXOR:
			opxy = op_XG
		case AXORW:
			opx = op_X
			opxy = op_XY
		}
		if opx != 0 && 0 <= d2 && d2 < DISP12 {
			zRX(opx, uint32(r1), uint32(x2), uint32(b2), uint32(d2), asm)
		} else {
			zRXY(opxy, uint32(r1), uint32(x2), uint32(b2), uint32(d2), asm)
		}

	case 13: // 循环，接着是操作
		r1 := p.To.Reg
		r2 := p.RestArgs[2].Reg
		i3 := uint8(p.From.Offset)        // 开始
		i4 := uint8(p.RestArgs[0].Offset) // 结束
		i5 := uint8(p.RestArgs[1].Offset) // 旋转量
		switch p.As {
		case ARNSBGT, ARXSBGT, AROSBGT:
			i3 |= 0x80 // 测试结果
		case ARISBGZ, ARISBGNZ, ARISBHGZ, ARISBLGZ:
			i4 |= 0x80 // 零剩余位
		}
		var opcode uint32
		switch p.As {
		case ARNSBG, ARNSBGT:
			opcode = op_RNSBG
		case ARXSBG, ARXSBGT:
			opcode = op_RXSBG
		case AROSBG, AROSBGT:
			opcode = op_ROSBG
		case ARISBG, ARISBGZ:
			opcode = op_RISBG
		case ARISBGN, ARISBGNZ:
			opcode = op_RISBGN
		case ARISBHG, ARISBHGZ:
			opcode = op_RISBHG
		case ARISBLG, ARISBLGZ:
			opcode = op_RISBLG
		}
		zRIE(_f, uint32(opcode), uint32(r1), uint32(r2), 0, uint32(i3), uint32(i4), 0, uint32(i5), asm)

	case 15: // br/bl（reg）
		r := p.To.Reg
		if p.As == ABCL || p.As == ABL {
			zRR(op_BASR, uint32(REG_LR), uint32(r), asm)
		} else {
			zRR(op_BCR, uint32(Always), uint32(r), asm)
		}

	case 16: // 条件分支
		v := int32(0)
		if p.To.Target() != nil {
			v = int32((p.To.Target().Pc - p.Pc) >> 1)
		}
		mask := uint32(c.branchMask(p))
		if p.To.Sym == nil && int32(int16(v)) == v {
			zRI(op_BRC, mask, uint32(v), asm)
		} else {
			zRIL(_c, op_BRCL, mask, uint32(v), asm)
		}
		if p.To.Sym != nil {
			c.addrilreloc(p.To.Sym, p.To.Offset)
		}

	case 17: // 移动条件
		m3 := uint32(c.branchMask(p))
		zRRF(op_LOCGR, m3, 0, uint32(p.To.Reg), uint32(p.From.Reg), asm)

	case 18: // br/bl reg 
		if p.As == ABL {
			zRR(op_BASR, uint32(REG_LR), uint32(p.To.Reg), asm)
		} else {
			zRR(op_BCR, uint32(Always), uint32(p.To.Reg), asm)
		}

	case 19: // mov$sym+n（SB）reg 
		d := c.vregoff(&p.From)
		zRIL(_b, op_LARL, uint32(p.To.Reg), 0, asm)
		if d&1 != 0 {
			zRX(op_LA, uint32(p.To.Reg), uint32(p.To.Reg), 0, 1, asm)
			d -= 1
		}
		c.addrilreloc(p.From.Sym, d)

	case 21: // 减去$constant[reg]reg 
		v := c.vregoff(&p.From)
		r := p.Reg
		if r == 0 {
			r = p.To.Reg
		}
		switch p.As {
		case ASUB:
			zRIL(_a, op_LGFI, uint32(regtmp(p)), uint32(v), asm)
			zRRF(op_SLGRK, uint32(regtmp(p)), 0, uint32(p.To.Reg), uint32(r), asm)
		case ASUBC:
			if r != p.To.Reg {
				zRRE(op_LGR, uint32(p.To.Reg), uint32(r), asm)
			}
			zRIL(_a, op_SLGFI, uint32(p.To.Reg), uint32(v), asm)
		case ASUBW:
			if r != p.To.Reg {
				zRR(op_LR, uint32(p.To.Reg), uint32(r), asm)
			}
			zRIL(_a, op_SLFI, uint32(p.To.Reg), uint32(v), asm)
		}

	case 22: // 加/乘$constant[reg]reg 
		v := c.vregoff(&p.From)
		r := p.Reg
		if r == 0 {
			r = p.To.Reg
		}
		var opri, opril, oprie uint32
		switch p.As {
		case AADD:
			opri = op_AGHI
			opril = op_AGFI
			oprie = op_AGHIK
		case AADDC:
			opril = op_ALGFI
			oprie = op_ALGHSIK
		case AADDW:
			opri = op_AHI
			opril = op_AFI
			oprie = op_AHIK
		case AMULLW:
			opri = op_MHI
			opril = op_MSFI
		case AMULLD:
			opri = op_MGHI
			opril = op_MSGFI
		}
		if r != p.To.Reg && (oprie == 0 || int64(int16(v)) != v) {
			switch p.As {
			case AADD, AADDC, AMULLD:
				zRRE(op_LGR, uint32(p.To.Reg), uint32(r), asm)
			case AADDW, AMULLW:
				zRR(op_LR, uint32(p.To.Reg), uint32(r), asm)
			}
			r = p.To.Reg
		}
		if opri != 0 && r == p.To.Reg && int64(int16(v)) == v {
			zRI(opri, uint32(p.To.Reg), uint32(v), asm)
		} else if oprie != 0 && int64(int16(v)) == v {
			zRIE(_d, oprie, uint32(p.To.Reg), uint32(r), uint32(v), 0, 0, 0, 0, asm)
		} else {
			zRIL(_a, opril, uint32(p.To.Reg), uint32(v), asm)
		}

	case 23: // 64位逻辑运算$constant reg 
		// TODO（mundaym）：与案例24合并。需要零扩展。Reg&0xFFFFFF00000000&uint32（v）
		v := c.vregoff(&p.From)
		switch p.As {
		default:
			c.ctxt.Diag("%v is not supported", p)
		case AAND:
				zRIL(_a, op_LGFI, regtmp(p), uint32(v), asm)
				zRRE(op_NGR, uint32(p.To.Reg), regtmp(p), asm)
			} else if int64(int16(v)) == v {
				zRI(op_NILL, uint32(p.To.Reg), uint32(v), asm)
				zRIL(_a, op_NILF, uint32(p.To.Reg), uint32(v), asm)
			}
		case AOR:
			if int64(uint32(v)) != v { // 需要符号扩展
				zRIL(_a, op_LGFI, regtmp(p), uint32(v), asm)
				zRRE(op_OGR, uint32(p.To.Reg), regtmp(p), asm)
			} else if int64(uint16(v)) == v {
				zRI(op_OILL, uint32(p.To.Reg), uint32(v), asm)
			} else {
				zRIL(_a, op_OILF, uint32(p.To.Reg), uint32(v), asm)
			}
		case AXOR:
			if int64(uint32(v)) != v { // 需要符号扩展
				zRIL(_a, op_LGFI, regtmp(p), uint32(v), asm)
				zRRE(op_XGR, uint32(p.To.Reg), regtmp(p), asm)
			} else {
				zRIL(_a, op_XILF, uint32(p.To.Reg), uint32(v), asm)
			}
		}

	case 24: // 32位逻辑运算$常量Reg 
		v := c.vregoff(&p.From)
		switch p.As {
		case AANDW:
			if uint32(v&0xffff0000) == 0xffff0000 {
				zRI(op_NILL, uint32(p.To.Reg), uint32(v), asm)
			} else if uint32(v&0x0000ffff) == 0x0000ffff {
				zRI(op_NILH, uint32(p.To.Reg), uint32(v)>>16, asm)
			} else {
				zRIL(_a, op_NILF, uint32(p.To.Reg), uint32(v), asm)
			}
		case AORW:
			if uint32(v&0xffff0000) == 0 {
				zRI(op_OILL, uint32(p.To.Reg), uint32(v), asm)
			} else if uint32(v&0x0000ffff) == 0 {
				zRI(op_OILH, uint32(p.To.Reg), uint32(v)>>16, asm)
			} else {
				zRIL(_a, op_OILF, uint32(p.To.Reg), uint32(v), asm)
			}
		case AXORW:
			zRIL(_a, op_XILF, uint32(p.To.Reg), uint32(v), asm)
		}

	case 25: // 加载条件（寄存器）
		m3 := uint32(c.branchMask(p))
		var opcode uint32
		switch p.As {
		case ALOCR:
			opcode = op_LOCR
		case ALOCGR:
			opcode = op_LOCGR
		}
		zRRF(opcode, m3, 0, uint32(p.To.Reg), uint32(p.Reg), asm)

	case 26: // MOVD$偏移量（基）（索引），reg 
		v := c.regoff(&p.From)
		r := p.From.Reg
		if r == 0 {
			r = REGSP
		}
		i := p.From.Index
		if v >= 0 && v < DISP12 {
			zRX(op_LA, uint32(p.To.Reg), uint32(r), uint32(i), uint32(v), asm)
		} else if v >= -DISP20/2 && v < DISP20/2 {
			zRXY(op_LAY, uint32(p.To.Reg), uint32(r), uint32(i), uint32(v), asm)
		} else {
			zRIL(_a, op_LGFI, regtmp(p), uint32(v), asm)
			zRX(op_LA, uint32(p.To.Reg), uint32(r), regtmp(p), uint32(i), asm)
		}

	case 31: // dword 
		wd := uint64(c.vregoff(&p.From))
		*asm = append(*asm,
			uint8(wd>>56),
			uint8(wd>>48),
			uint8(wd>>40),
			uint8(wd>>32),
			uint8(wd>>24),
			uint8(wd>>16),
			uint8(wd>>8),
			uint8(wd))

	case 32: // float op freg freg 
		var opcode uint32
		switch p.As {
		default:
			c.ctxt.Diag("invalid opcode")
		case AFADD:
			opcode = op_ADBR
		case AFADDS:
			opcode = op_AEBR
		case AFDIV:
			opcode = op_DDBR
		case AFDIVS:
			opcode = op_DEBR
		case AFMUL:
			opcode = op_MDBR
		case AFMULS:
			opcode = op_MEEBR
		case AFSUB:
			opcode = op_SDBR
		case AFSUBS:
			opcode = op_SEBR
		}
		zRRE(opcode, uint32(p.To.Reg), uint32(p.From.Reg), asm)

	case 33: // float op[freg]freg 
		r := p.From.Reg
		if oclass(&p.From) == C_NONE {
			r = p.To.Reg
		}
		var opcode uint32
		switch p.As {
		default:
		case AFABS:
			opcode = op_LPDBR
		case AFNABS:
			opcode = op_LNDBR
		case ALPDFR:
			opcode = op_LPDFR
		case ALNDFR:
			opcode = op_LNDFR
		case AFNEG:
			opcode = op_LCDFR
		case AFNEGS:
			opcode = op_LCEBR
		case ALEDBR:
			opcode = op_LEDBR
		case ALDEBR:
			opcode = op_LDEBR
		case AFSQRT:
			opcode = op_SQDBR
		case AFSQRTS:
			opcode = op_SQEBR
		}
		zRRE(opcode, uint32(p.To.Reg), uint32(r), asm)

	case 34: // float乘法加法freg freg freg 
		var opcode uint32
		switch p.As {
		default:
			c.ctxt.Diag("invalid opcode")
		case AFMADD:
			opcode = op_MADBR
		case AFMADDS:
			opcode = op_MAEBR
		case AFMSUB:
			opcode = op_MSDBR
		case AFMSUBS:
			opcode = op_MSEBR
		}
		zRRD(opcode, uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg), asm)

	case 35: // mov reg mem（无重定位）
		d2 := c.regoff(&p.To)
		b2 := p.To.Reg
		if b2 == 0 {
			b2 = REGSP
		}
		x2 := p.To.Index
		if d2 < -DISP20/2 || d2 >= DISP20/2 {
			zRIL(_a, op_LGFI, regtmp(p), uint32(d2), asm)
			if x2 != 0 {
				zRX(op_LA, regtmp(p), regtmp(p), uint32(x2), 0, asm)
			}
			x2 = int16(regtmp(p))
			d2 = 0
		}
		// 如果存在合适的指令且位移适合12位，则发出RX指令。否则使用RXY指令。
		if op, ok := c.zopstore12(p.As); ok && isU12(d2) {
			zRX(op, uint32(p.From.Reg), uint32(x2), uint32(b2), uint32(d2), asm)
		} else {
			zRXY(c.zopstore(p.As), uint32(p.From.Reg), uint32(x2), uint32(b2), uint32(d2), asm)
		}

	case 36: // mov mem reg（无重定位）
		d2 := c.regoff(&p.From)
		b2 := p.From.Reg
		if b2 == 0 {
			b2 = REGSP
		}
		x2 := p.From.Index
		if d2 < -DISP20/2 || d2 >= DISP20/2 {
			zRIL(_a, op_LGFI, regtmp(p), uint32(d2), asm)
			if x2 != 0 {
				zRX(op_LA, regtmp(p), regtmp(p), uint32(x2), 0, asm)
			}
			x2 = int16(regtmp(p))
			d2 = 0
		}
		// 如果存在适当的RX指令，并且位移适合12位，则会发出RX指令。否则使用RXY指令。
		if op, ok := c.zopload12(p.As); ok && isU12(d2) {
			zRX(op, uint32(p.To.Reg), uint32(x2), uint32(b2), uint32(d2), asm)
		} else {
			zRXY(c.zopload(p.As), uint32(p.To.Reg), uint32(x2), uint32(b2), uint32(d2), asm)
		}

	case 40: // word/byte 
		wd := uint32(c.regoff(&p.From))
		if p.As == AWORD { // word 
			*asm = append(*asm, uint8(wd>>24), uint8(wd>>16), uint8(wd>>8), uint8(wd))
		} else { // byte 
			*asm = append(*asm, uint8(wd))
		}

	case 41: // 计数分支
		r1 := p.From.Reg
		ri2 := (p.To.Target().Pc - p.Pc) >> 1
		if int64(int16(ri2)) != ri2 {
			c.ctxt.Diag("branch target too far away")
		}
		var opcode uint32
		switch p.As {
		case ABRCT:
			opcode = op_BRCT
		case ABRCTG:
			opcode = op_BRCTG
		}
		zRI(opcode, uint32(r1), uint32(ri2), asm)

	case 47: // 否定[reg]reg 
		r := p.From.Reg
		if r == 0 {
			r = p.To.Reg
		}
		switch p.As {
		case ANEG:
			zRRE(op_LCGR, uint32(p.To.Reg), uint32(r), asm)
		case ANEGW:
			zRRE(op_LCGFR, uint32(p.To.Reg), uint32(r), asm)
		}

	case 48: // 浮点舍入到整数
		m3 := c.vregoff(&p.From)
		if 0 > m3 || m3 > 7 {
			c.ctxt.Diag("mask (%v) must be in the range [0, 7]", m3)
		}
		var opcode uint32
		switch p.As {
		case AFIEBR:
			opcode = op_FIEBR
		case AFIDBR:
			opcode = op_FIDBR
		}
		zRRF(opcode, uint32(m3), 0, uint32(p.To.Reg), uint32(p.Reg), asm)

	case 49: // 复制签名
		zRRF(op_CPSDR, uint32(p.From.Reg), 0, uint32(p.To.Reg), uint32(p.Reg), asm)

	case 50: // 加载并测试
		var opcode uint32
		switch p.As {
		case ALTEBR:
			opcode = op_LTEBR
		case ALTDBR:
			opcode = op_LTDBR
		}
		zRRE(opcode, uint32(p.To.Reg), uint32(p.From.Reg), asm)

	case 51: // 测试数据类（仅限立即数）
		var opcode uint32
		switch p.As {
		case ATCEB:
			opcode = op_TCEB
		case ATCDB:
			opcode = op_TCDB
		}
		d2 := c.regoff(&p.To)
		zRXE(opcode, uint32(p.From.Reg), 0, 0, uint32(d2), 0, asm)

	case 62: // 与Mul64中的等效项数学/比特数
		zRRE(op_MLGR, uint32(p.To.Reg), uint32(p.From.Reg), asm)

	case 66:
		zRR(op_BCR, uint32(Never), 0, asm)

	case 67: // fmov$0 freg 
		var opcode uint32
		switch p.As {
		case AFMOVS:
			opcode = op_LZER
		case AFMOVD:
			opcode = op_LZDR
		}
		zRRE(opcode, uint32(p.To.Reg), 0, asm)

	case 68: // movw areg 
		zRRE(op_EAR, uint32(p.To.Reg), uint32(p.From.Reg-REG_AR0), asm)

	case 69: // movw reg areg 
		zRRE(op_SAR, uint32(p.To.Reg-REG_AR0), uint32(p.From.Reg), asm)

	case 70: // cmp reg 
		if p.As == ACMPW || p.As == ACMPWU {
			zRR(c.zoprr(p.As), uint32(p.From.Reg), uint32(p.To.Reg), asm)
		} else {
			zRRE(c.zoprre(p.As), uint32(p.From.Reg), uint32(p.To.Reg), asm)
		}

	case 71: // cmp reg constant 
		v := c.vregoff(&p.To)
		switch p.As {
		case ACMP, ACMPW:
			if int64(int32(v)) != v {
				c.ctxt.Diag("%v overflows an int32", v)
			}
		case ACMPU, ACMPWU:
			if int64(uint32(v)) != v {
				c.ctxt.Diag("%v overflows a uint32", v)
			}
		}
		if p.As == ACMP && int64(int16(v)) == v {
			zRI(op_CGHI, uint32(p.From.Reg), uint32(v), asm)
		} else if p.As == ACMPW && int64(int16(v)) == v {
			zRI(op_CHI, uint32(p.From.Reg), uint32(v), asm)
		} else {
			zRIL(_a, c.zopril(p.As), uint32(p.From.Reg), uint32(v), asm)
		}

	case 72: // mov$constant mem 
		v := c.regoff(&p.From)
		d := c.regoff(&p.To)
		r := p.To.Reg
		if p.To.Index != 0 {
			c.ctxt.Diag("cannot use index register")
		}
		if r == 0 {
			r = REGSP
		}
		var opcode uint32
		switch p.As {
		case AMOVD:
			opcode = op_MVGHI
		case AMOVW, AMOVWZ:
			opcode = op_MVHI
		case AMOVH, AMOVHZ:
			opcode = op_MVHHI
		case AMOVB, AMOVBZ:
			opcode = op_MVI
		}
		if d < 0 || d >= DISP12 {
			if r == int16(regtmp(p)) {
				c.ctxt.Diag("displacement must be in range [0, 4096) to use %v", r)
			}
			if d >= -DISP20/2 && d < DISP20/2 {
				if opcode == op_MVI {
					opcode = op_MVIY
				} else {
					zRXY(op_LAY, uint32(regtmp(p)), 0, uint32(r), uint32(d), asm)
					r = int16(regtmp(p))
					d = 0
				}
			} else {
				zRIL(_a, op_LGFI, regtmp(p), uint32(d), asm)
				zRX(op_LA, regtmp(p), regtmp(p), uint32(r), 0, asm)
				r = int16(regtmp(p))
				d = 0
			}
		}
		switch opcode {
		case op_MVI:
			zSI(opcode, uint32(v), uint32(r), uint32(d), asm)
		case op_MVIY:
			zSIY(opcode, uint32(v), uint32(r), uint32(d), asm)
		default:
			zSIL(opcode, uint32(r), uint32(d), uint32(v), asm)
		}

	case 74: // mov reg addr（包括重新定位）
		i2 := c.regoff(&p.To)
		switch p.As {
		case AMOVD:
			zRIL(_b, op_STGRL, uint32(p.From.Reg), 0, asm)
		case AMOVW, AMOVWZ: // 零扩展不影响存储指令
			zRIL(_b, op_STRL, uint32(p.From.Reg), 0, asm)
			zRIL(_b, op_STHRL, uint32(p.From.Reg), 0, asm)
		case AMOVB, AMOVBZ: // 零扩展不影响存储指令
			zRIL(_b, op_LARL, regtmp(p), 0, asm)
			adj := uint32(0) // 奇数地址需要调整
			if i2&1 != 0 {
				i2 -= 1
				adj = 1
			}
			zRX(op_STC, uint32(p.From.Reg), 0, regtmp(p), adj, asm)
		case AFMOVD:
			zRIL(_b, op_LARL, regtmp(p), 0, asm)
			zRX(op_STD, uint32(p.From.Reg), 0, regtmp(p), 0, asm)
		case AFMOVS:
			zRIL(_b, op_LARL, regtmp(p), 0, asm)
			zRX(op_STE, uint32(p.From.Reg), 0, regtmp(p), 0, asm)
		}
		c.addrilreloc(p.To.Sym, int64(i2))

	case 75: // mov addr reg（包括重新定位）
		i2 := c.regoff(&p.From)
		switch p.As {
		case AMOVD:
			if i2&1 != 0 {
				zRIL(_b, op_LARL, regtmp(p), 0, asm)
				zRXY(op_LG, uint32(p.To.Reg), regtmp(p), 0, 1, asm)
				i2 -= 1
			} else {
				zRIL(_b, op_LGRL, uint32(p.To.Reg), 0, asm)
			}
		case AMOVW:
			zRIL(_b, op_LGFRL, uint32(p.To.Reg), 0, asm)
		case AMOVWZ:
			zRIL(_b, op_LLGFRL, uint32(p.To.Reg), 0, asm)
		case AMOVH:
			zRIL(_b, op_LGHRL, uint32(p.To.Reg), 0, asm)
		case AMOVHZ:
			zRIL(_b, op_LLGHRL, uint32(p.To.Reg), 0, asm)
		case AMOVB, AMOVBZ:
			zRIL(_b, op_LARL, regtmp(p), 0, asm)
			adj := uint32(0) // 奇数地址需要调整
			if i2&1 != 0 {
				i2 -= 1
				adj = 1
			}
			switch p.As {
			case AMOVB:
				zRXY(op_LGB, uint32(p.To.Reg), 0, regtmp(p), adj, asm)
			case AMOVBZ:
				zRXY(op_LLGC, uint32(p.To.Reg), 0, regtmp(p), adj, asm)
			}
		case AFMOVD:
			zRIL(_a, op_LARL, regtmp(p), 0, asm)
			zRX(op_LD, uint32(p.To.Reg), 0, regtmp(p), 0, asm)
		case AFMOVS:
			zRIL(_a, op_LARL, regtmp(p), 0, asm)
			zRX(op_LE, uint32(p.To.Reg), 0, regtmp(p), 0, asm)
		}
		c.addrilreloc(p.From.Sym, int64(i2))

	case 76: // 设置程序掩码
		zRR(op_SPM, uint32(p.From.Reg), 0, asm)

	case 77: // 系统调用$constant 
		if p.From.Offset > 255 || p.From.Offset < 1 {
			c.ctxt.Diag("illegal system call; system call number out of range: %v", p)
			zE(op_TRAP2, asm) // 陷阱始终
		} else {
			zI(op_SVC, uint32(p.From.Offset), asm)
		}

	case 78: // 未定义
		// “完全由二进制0组成的指令保证
		// 始终是非法指令。”
		*asm = append(*asm, 0, 0, 0, 0)

	case 79: // 比较和交换reg reg reg reg 
		v := c.regoff(&p.To)
		if v < 0 {
			v = 0
		}
		if p.As == ACS {
			zRS(op_CS, uint32(p.From.Reg), uint32(p.Reg), uint32(p.To.Reg), uint32(v), asm)
		} else if p.As == ACSG {
			zRSY(op_CSG, uint32(p.From.Reg), uint32(p.Reg), uint32(p.To.Reg), uint32(v), asm)
		}

	case 80: // 同步
		zRR(op_BCR, 14, 0, asm) // 快速BCR序列化

	case 81: // 浮点到固定和固定到浮点移动（无转换）
		switch p.As {
		case ALDGR:
			zRRE(op_LDGR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
		case ALGDR:
			zRRE(op_LGDR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
		}

	case 82: // 固定到浮点转换
		var opcode uint32
		switch p.As {
		default:
			log.Fatalf("unexpected opcode %v", p.As)
		case ACEFBRA:
			opcode = op_CEFBRA
		case ACDFBRA:
			opcode = op_CDFBRA
		case ACEGBRA:
			opcode = op_CEGBRA
		case ACDGBRA:
			opcode = op_CDGBRA
		case ACELFBR:
			opcode = op_CELFBR
		case ACDLFBR:
			opcode = op_CDLFBR
		case ACELGBR:
			opcode = op_CELGBR
		case ACDLGBR:
			opcode = op_CDLGBR
		}
		// 将立即操作数M3设置为0以使用默认的BFP舍入模式
		// TODO（mundaym）：这应该固定在四舍五入到最近，与偶数成正比吗？
		// M4是保留的，必须是0 
		zRRF(opcode, 0, 0, uint32(p.To.Reg), uint32(p.From.Reg), asm)

	case 83: // 浮点到固定转换
		var opcode uint32
		switch p.As {
		default:
			log.Fatalf("unexpected opcode %v", p.As)
		case ACFEBRA:
			opcode = op_CFEBRA
		case ACFDBRA:
			opcode = op_CFDBRA
		case ACGEBRA:
			opcode = op_CGEBRA
		case ACGDBRA:
			opcode = op_CGDBRA
		case ACLFEBR:
			opcode = op_CLFEBR
		case ACLFDBR:
			opcode = op_CLFDBR
		case ACLGEBR:
			opcode = op_CLGEBR
		case ACLGDBR:
			opcode = op_CLGDBR
		}
		// 将立即操作数M3设置为5，以便向零舍入（Go规范要求）
		// M4是保留的，必须是0 
		zRRF(opcode, 5, 0, uint32(p.To.Reg), uint32(p.From.Reg), asm)

	case 84: // 存储和存储操作$length mem 
		l := c.regoff(&p.From)
		if l < 1 || l > 256 {
			c.ctxt.Diag("number of bytes (%v) not in range [1,256]", l)
		}
		if p.GetFrom3().Index != 0 || p.To.Index != 0 {
			c.ctxt.Diag("cannot use index reg")
		}
		b1 := p.To.Reg
		b2 := p.GetFrom3().Reg
		if b1 == 0 {
			b1 = REGSP
		}
		if b2 == 0 {
			b2 = REGSP
		}
		d1 := c.regoff(&p.To)
		d2 := c.regoff(p.GetFrom3())
		if d1 < 0 || d1 >= DISP12 {
			if b2 == int16(regtmp(p)) {
				c.ctxt.Diag("regtmp(p) conflict")
			}
			if b1 != int16(regtmp(p)) {
				zRRE(op_LGR, regtmp(p), uint32(b1), asm)
			}
			zRIL(_a, op_AGFI, regtmp(p), uint32(d1), asm)
			if d1 == d2 && b1 == b2 {
				d2 = 0
				b2 = int16(regtmp(p))
			}
			d1 = 0
			b1 = int16(regtmp(p))
		}
		if d2 < 0 || d2 >= DISP12 {
			if b1 == REGTMP2 {
				c.ctxt.Diag("REGTMP2 conflict")
			}
			if b2 != REGTMP2 {
				zRRE(op_LGR, REGTMP2, uint32(b2), asm)
			}
			zRIL(_a, op_AGFI, REGTMP2, uint32(d2), asm)
			d2 = 0
			b2 = REGTMP2
		}
		var opcode uint32
		switch p.As {
		default:
			c.ctxt.Diag("unexpected opcode %v", p.As)
		case AMVC:
			opcode = op_MVC
		case AMVCIN:
			opcode = op_MVCIN
		case ACLC:
			opcode = op_CLC
			// 交换CLC的操作数顺序，使其与CMP匹配
			b1, b2 = b2, b1
			d1, d2 = d2, d1
		case AXC:
			opcode = op_XC
		case AOC:
			opcode = op_OC
		case ANC:
			opcode = op_NC
		}
		zSS(_a, opcode, uint32(l-1), 0, uint32(b1), uint32(d1), uint32(b2), uint32(d2), asm)

	case 85: // 加载地址相对长
		v := c.regoff(&p.From)
		if p.From.Sym == nil {
			if (v & 1) != 0 {
				c.ctxt.Diag("cannot use LARL with odd offset: %v", v)
			}
		} else {
			c.addrilreloc(p.From.Sym, int64(v))
			v = 0
		}
		zRIL(_b, op_LARL, uint32(p.To.Reg), uint32(v>>1), asm)

	case 86: // 加载地址
		d := c.vregoff(&p.From)
		x := p.From.Index
		b := p.From.Reg
		if b == 0 {
			b = REGSP
		}
		switch p.As {
		case ALA:
			zRX(op_LA, uint32(p.To.Reg), uint32(x), uint32(b), uint32(d), asm)
		case ALAY:
			zRXY(op_LAY, uint32(p.To.Reg), uint32(x), uint32(b), uint32(d), asm)
		}

	case 87: // 执行相对长
		v := c.vregoff(&p.From)
		if p.From.Sym == nil {
			if v&1 != 0 {
				c.ctxt.Diag("cannot use EXRL with odd offset: %v", v)
			}
		} else {
			c.addrilreloc(p.From.Sym, v)
			v = 0
		}
		zRIL(_b, op_EXRL, uint32(p.To.Reg), uint32(v>>1), asm)

	case 88: // 存储时钟
		var opcode uint32
		switch p.As {
		case ASTCK:
			opcode = op_STCK
		case ASTCKC:
			opcode = op_STCKC
		case ASTCKE:
			opcode = op_STCKE
		case ASTCKF:
			opcode = op_STCKF
		}
		v := c.vregoff(&p.To)
		r := p.To.Reg
		if r == 0 {
			r = REGSP
		}
		zS(opcode, uint32(r), uint32(v), asm)

	case 89: // 比较和分支注册
		var v int32
		if p.To.Target() != nil {
			v = int32((p.To.Target().Pc - p.Pc) >> 1)
		}

		// 一些指令将掩码作为第一个参数。
		r1, r2 := p.From.Reg, p.Reg
		if p.From.Type == obj.TYPE_CONST {
			r1, r2 = p.Reg, p.RestArgs[0].Reg
		}
		m3 := uint32(c.branchMask(p))

		var opcode uint32
		switch p.As {
		case ACRJ:
			// 比较和分支相对（32）
			opcode = op_CRJ
		case ACGRJ, ACMPBEQ, ACMPBGE, ACMPBGT, ACMPBLE, ACMPBLT, ACMPBNE:
			// 比较和分支相对（64）
			opcode = op_CGRJ
		case ACLRJ:
			// 比较逻辑和分支相对（32）
			opcode = op_CLRJ
		case ACLGRJ, ACMPUBEQ, ACMPUBGE, ACMPUBGT, ACMPUBLE, ACMPUBLT, ACMPUBNE:
			// 比较逻辑和分支相对（64）
			opcode = op_CLGRJ
		}

		if int32(int16(v)) != v {
			// 分支对于一条指令来说太远，所以破解
			// /`CMPBEQ x，y，target`into:
			// 
			// CMPBNE x，y，2（PC）
			// BR target 
			// 
			// 注意指令序列不能与
			// 条件代码冲突。
			m3 ^= 0xe // 反转3位掩码
			zRIE(_b, opcode, uint32(r1), uint32(r2), uint32(sizeRIE+sizeRIL)/2, 0, 0, m3, 0, asm)
			zRIL(_c, op_BRCL, uint32(Always), uint32(v-sizeRIE/2), asm)
		} else {
			zRIE(_b, opcode, uint32(r1), uint32(r2), uint32(v), 0, 0, m3, 0, asm)
		}

	case 90: // 比较和分支寄存器$constant 
		var v int32
		if p.To.Target() != nil {
			v = int32((p.To.Target().Pc - p.Pc) >> 1)
		}

		// 一些指令将掩码作为第一个参数。
		r1, i2 := p.From.Reg, p.RestArgs[0].Offset
		if p.From.Type == obj.TYPE_CONST {
			r1 = p.Reg
		}
		m3 := uint32(c.branchMask(p))

		var opcode uint32
		switch p.As {
		case ACIJ:
			opcode = op_CIJ
		case ACGIJ, ACMPBEQ, ACMPBGE, ACMPBGT, ACMPBLE, ACMPBLT, ACMPBNE:
			opcode = op_CGIJ
		case ACLIJ:
			opcode = op_CLIJ
		case ACLGIJ, ACMPUBEQ, ACMPUBGE, ACMPUBGT, ACMPUBLE, ACMPUBLT, ACMPUBNE:
			opcode = op_CLGIJ
		}
		if int32(int16(v)) != v {
			// 分支对于一条指令来说太远了，所以将
			// /`CMPBEQ x，$0，target`分解为：
			// 
			// CMPBNE x，$0，2（PC）
			// BR target 
			// 
			// 注意指令序列不能与
			// 条件代码冲突。
			m3 ^= 0xe // 反转3位掩码
			zRIE(_c, opcode, uint32(r1), m3, uint32(sizeRIE+sizeRIL)/2, 0, 0, 0, uint32(i2), asm)
			zRIL(_c, op_BRCL, uint32(Always), uint32(v-sizeRIE/2), asm)
		} else {
			zRIE(_c, opcode, uint32(r1), m3, uint32(v), 0, 0, 0, uint32(i2), asm)
		}

	case 91: // 在掩码下测试（立即）
		var opcode uint32
		switch p.As {
		case ATMHH:
			opcode = op_TMHH
		case ATMHL:
			opcode = op_TMHL
		case ATMLH:
			opcode = op_TMLH
		case ATMLL:
			opcode = op_TMLL
		}
		zRI(opcode, uint32(p.From.Reg), uint32(c.vregoff(&p.To)), asm)

	case 92: // 插入程序掩码
		zRRE(op_IPM, uint32(p.From.Reg), 0, asm)

	case 93: // 获得查找
		v := c.vregoff(&p.To)
		if v != 0 {
			c.ctxt.Diag("invalid offset against GOT slot %v", p)
		}
		zRIL(_b, op_LGRL, uint32(p.To.Reg), 0, asm)
		rel := obj.Addrel(c.cursym)
		rel.Off = int32(c.pc + 2)
		rel.Siz = 4
		rel.Sym = p.From.Sym
		rel.Type = objabi.R_GOTPCREL
		rel.Add = 2 + int64(rel.Siz)

	case 94: // TLS本地执行模型
		zRIL(_b, op_LARL, regtmp(p), (sizeRIL+sizeRXY+sizeRI)>>1, asm)
		zRXY(op_LG, uint32(p.To.Reg), regtmp(p), 0, 0, asm)
		zRI(op_BRC, 0xF, (sizeRI+8)>>1, asm)
		*asm = append(*asm, 0, 0, 0, 0, 0, 0, 0, 0)
		rel := obj.Addrel(c.cursym)
		rel.Off = int32(c.pc + sizeRIL + sizeRXY + sizeRI)
		rel.Siz = 8
		rel.Sym = p.From.Sym
		rel.Type = objabi.R_TLS_LE
		rel.Add = 0

	case 95: // TLS初始执行模型
		// 组装|重新定位符号|在这里完成？
		// /----------------------------------------------------------------
		// ear%r11、%a0 | | 
		// sllg%r11、%r11、%32 | | 
		// ear%r11、%a1 | | 
		// larl%r10，<var>@indntpoff | R|u 390|TLS|IEENT | Y 
		// lg%r10,0（%r10）| R|u 390|u TLS|u LOAD（tag）| Y 
		// /----------------------------------------------------------------

		// R_390_TLS_IENT 
		zRIL(_b, op_LARL, regtmp(p), 0, asm)
		ieent := obj.Addrel(c.cursym)
		ieent.Off = int32(c.pc + 2)
		ieent.Siz = 4
		ieent.Sym = p.From.Sym
		ieent.Type = objabi.R_TLS_IE
		ieent.Add = 2 + int64(ieent.Siz)

		// R_390_TLS_加载
		zRXY(op_LGF, uint32(p.To.Reg), regtmp(p), 0, 0, asm)
		// TODO（星期日）：在此处添加R_390_TLS_加载重新定位
		// 不严格要求，但可能允许链接器优化

	case 96: // 
		length := c.vregoff(&p.From)
		offset := c.vregoff(&p.To)
		reg := p.To.Reg
		if reg == 0 {
			reg = REGSP
		}
		if length <= 0 {
			c.ctxt.Diag("cannot CLEAR %d bytes, must be greater than 0", length)
		}
		for length > 0 {
			if offset < 0 || offset >= DISP12 {
				if offset >= -DISP20/2 && offset < DISP20/2 {
					zRXY(op_LAY, regtmp(p), uint32(reg), 0, uint32(offset), asm)
				} else {
					if reg != int16(regtmp(p)) {
						zRRE(op_LGR, regtmp(p), uint32(reg), asm)
					}
					zRIL(_a, op_AGFI, regtmp(p), uint32(offset), asm)
				}
				reg = int16(regtmp(p))
				offset = 0
			}
			size := length
			if size > 256 {
				size = 256
			}

			switch size {
			case 1:
				zSI(op_MVI, 0, uint32(reg), uint32(offset), asm)
			case 2:
				zSIL(op_MVHHI, uint32(reg), uint32(offset), 0, asm)
			case 4:
				zSIL(op_MVHI, uint32(reg), uint32(offset), 0, asm)
			case 8:
				zSIL(op_MVGHI, uint32(reg), uint32(offset), 0, asm)
			default:
				zSS(_a, op_XC, uint32(size-1), 0, uint32(reg), uint32(offset), uint32(reg), uint32(offset), asm)
			}

			length -= size
			offset += size
		}

	case 97: // 存储多个
		rstart := p.From.Reg
		rend := p.Reg
		offset := c.regoff(&p.To)
		reg := p.To.Reg
		if reg == 0 {
			reg = REGSP
		}
		if offset < -DISP20/2 || offset >= DISP20/2 {
			if reg != int16(regtmp(p)) {
				zRRE(op_LGR, regtmp(p), uint32(reg), asm)
			}
			zRIL(_a, op_AGFI, regtmp(p), uint32(offset), asm)
			reg = int16(regtmp(p))
			offset = 0
		}
		switch p.As {
		case ASTMY:
			if offset >= 0 && offset < DISP12 {
				zRS(op_STM, uint32(rstart), uint32(rend), uint32(reg), uint32(offset), asm)
			} else {
				zRSY(op_STMY, uint32(rstart), uint32(rend), uint32(reg), uint32(offset), asm)
			}
		case ASTMG:
			zRSY(op_STMG, uint32(rstart), uint32(rend), uint32(reg), uint32(offset), asm)
		}

	case 98: // 加载多个
		rstart := p.Reg
		rend := p.To.Reg
		offset := c.regoff(&p.From)
		reg := p.From.Reg
		if reg == 0 {
			reg = REGSP
		}
		if offset < -DISP20/2 || offset >= DISP20/2 {
			if reg != int16(regtmp(p)) {
				zRRE(op_LGR, regtmp(p), uint32(reg), asm)
			}
			zRIL(_a, op_AGFI, regtmp(p), uint32(offset), asm)
			reg = int16(regtmp(p))
			offset = 0
		}
		switch p.As {
		case ALMY:
			if offset >= 0 && offset < DISP12 {
				zRS(op_LM, uint32(rstart), uint32(rend), uint32(reg), uint32(offset), asm)
			} else {
				zRSY(op_LMY, uint32(rstart), uint32(rend), uint32(reg), uint32(offset), asm)
			}
		case ALMG:
			zRSY(op_LMG, uint32(rstart), uint32(rend), uint32(reg), uint32(offset), asm)
		}

	case 99: // 联锁加载和op 
		if p.To.Index != 0 {
			c.ctxt.Diag("cannot use indexed address")
		}
		offset := c.regoff(&p.To)
		if offset < -DISP20/2 || offset >= DISP20/2 {
			c.ctxt.Diag("%v does not fit into 20-bit signed integer", offset)
		}
		var opcode uint32
		switch p.As {
		case ALAA:
			opcode = op_LAA
		case ALAAG:
			opcode = op_LAAG
		case ALAAL:
			opcode = op_LAAL
		case ALAALG:
			opcode = op_LAALG
		case ALAN:
			opcode = op_LAN
		case ALANG:
			opcode = op_LANG
		case ALAX:
			opcode = op_LAX
		case ALAXG:
			opcode = op_LAXG
		case ALAO:
			opcode = op_LAO
		case ALAOG:
			opcode = op_LAOG
		}
		zRSY(opcode, uint32(p.Reg), uint32(p.From.Reg), uint32(p.To.Reg), uint32(offset), asm)

	case 100: // VRX存储
		op, m3, _ := vop(p.As)
		v1 := p.From.Reg
		if p.Reg != 0 {
			m3 = uint32(c.vregoff(&p.From))
			v1 = p.Reg
		}
		b2 := p.To.Reg
		if b2 == 0 {
			b2 = REGSP
		}
		d2 := uint32(c.vregoff(&p.To))
		zVRX(op, uint32(v1), uint32(p.To.Index), uint32(b2), d2, m3, asm)

	case 101: // VRX加载
		op, m3, _ := vop(p.As)
		src := &p.From
		if p.GetFrom3() != nil {
			m3 = uint32(c.vregoff(&p.From))
			src = p.GetFrom3()
		}
		b2 := src.Reg
		if b2 == 0 {
			b2 = REGSP
		}
		d2 := uint32(c.vregoff(src))
		zVRX(op, uint32(p.To.Reg), uint32(src.Index), uint32(b2), d2, m3, asm)

	case 102: // VRV分散
		op, _, _ := vop(p.As)
		m3 := uint32(c.vregoff(&p.From))
		b2 := p.To.Reg
		if b2 == 0 {
			b2 = REGSP
		}
		d2 := uint32(c.vregoff(&p.To))
		zVRV(op, uint32(p.Reg), uint32(p.To.Index), uint32(b2), d2, m3, asm)

	case 103: // VRV聚集
		op, _, _ := vop(p.As)
		m3 := uint32(c.vregoff(&p.From))
		b2 := p.GetFrom3().Reg
		if b2 == 0 {
			b2 = REGSP
		}
		d2 := uint32(c.vregoff(p.GetFrom3()))
		zVRV(op, uint32(p.To.Reg), uint32(p.GetFrom3().Index), uint32(b2), d2, m3, asm)

	case 104: // VRS移位/旋转并从VR元件加载GR 
		op, m4, _ := vop(p.As)
		fr := p.Reg
		if fr == 0 {
			fr = p.To.Reg
		}
		bits := uint32(c.vregoff(&p.From))
		zVRS(op, uint32(p.To.Reg), uint32(fr), uint32(p.From.Reg), bits, m4, asm)

	case 105: // VRS存储多个
		op, _, _ := vop(p.As)
		offset := uint32(c.vregoff(&p.To))
		reg := p.To.Reg
		if reg == 0 {
			reg = REGSP
		}
		zVRS(op, uint32(p.From.Reg), uint32(p.Reg), uint32(reg), offset, 0, asm)

	case 106: // VRS加载多个
		op, _, _ := vop(p.As)
		offset := uint32(c.vregoff(&p.From))
		reg := p.From.Reg
		if reg == 0 {
			reg = REGSP
		}
		zVRS(op, uint32(p.Reg), uint32(p.To.Reg), uint32(reg), offset, 0, asm)

	case 107: // VRS存储长度
		op, _, _ := vop(p.As)
		offset := uint32(c.vregoff(&p.To))
		reg := p.To.Reg
		if reg == 0 {
			reg = REGSP
		}
		zVRS(op, uint32(p.Reg), uint32(p.From.Reg), uint32(reg), offset, 0, asm)

	case 108: // VRS加载长度
		op, _, _ := vop(p.As)
		offset := uint32(c.vregoff(p.GetFrom3()))
		reg := p.GetFrom3().Reg
		if reg == 0 {
			reg = REGSP
		}
		zVRS(op, uint32(p.To.Reg), uint32(p.From.Reg), uint32(reg), offset, 0, asm)

	case 109: // VRI-a 
		op, m3, _ := vop(p.As)
		i2 := uint32(c.vregoff(&p.From))
		if p.GetFrom3() != nil {
			m3 = uint32(c.vregoff(&p.From))
			i2 = uint32(c.vregoff(p.GetFrom3()))
		}
		switch p.As {
		case AVZERO:
			i2 = 0
		case AVONE:
			i2 = 0xffff
		}
		zVRIa(op, uint32(p.To.Reg), i2, m3, asm)

	case 110:
		op, m4, _ := vop(p.As)
		i2 := uint32(c.vregoff(&p.From))
		i3 := uint32(c.vregoff(p.GetFrom3()))
		zVRIb(op, uint32(p.To.Reg), i2, i3, m4, asm)

	case 111:
		op, m4, _ := vop(p.As)
		i2 := uint32(c.vregoff(&p.From))
		zVRIc(op, uint32(p.To.Reg), uint32(p.Reg), i2, m4, asm)

	case 112:
		op, m5, _ := vop(p.As)
		i4 := uint32(c.vregoff(&p.From))
		zVRId(op, uint32(p.To.Reg), uint32(p.Reg), uint32(p.GetFrom3().Reg), i4, m5, asm)

	case 113:
		op, m4, _ := vop(p.As)
		m5 := singleElementMask(p.As)
		i3 := uint32(c.vregoff(&p.From))
		zVRIe(op, uint32(p.To.Reg), uint32(p.Reg), i3, m5, m4, asm)

	case 114: // VRR-a 
		op, m3, m5 := vop(p.As)
		m4 := singleElementMask(p.As)
		zVRRa(op, uint32(p.To.Reg), uint32(p.From.Reg), m5, m4, m3, asm)

	case 115: // VRR-a比较
		op, m3, m5 := vop(p.As)
		m4 := singleElementMask(p.As)
		zVRRa(op, uint32(p.From.Reg), uint32(p.To.Reg), m5, m4, m3, asm)

	case 117: // VRR-b 
		op, m4, m5 := vop(p.As)
		zVRRb(op, uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg), m5, m4, asm)

	case 118: // VRR-c 
		op, m4, m6 := vop(p.As)
		m5 := singleElementMask(p.As)
		v3 := p.Reg
		if v3 == 0 {
			v3 = p.To.Reg
		}
		zVRRc(op, uint32(p.To.Reg), uint32(p.From.Reg), uint32(v3), m6, m5, m4, asm)

	case 119: // VRR-c SHIFT/ROTATE/DIVIDE/SUB（左侧的rhs值，如SLD、DIV等）
		op, m4, m6 := vop(p.As)
		m5 := singleElementMask(p.As)
		v2 := p.Reg
		if v2 == 0 {
			v2 = p.To.Reg
		}
		zVRRc(op, uint32(p.To.Reg), uint32(v2), uint32(p.From.Reg), m6, m5, m4, asm)

		op, m6, _ := vop(p.As)
		m5 := singleElementMask(p.As)
		v1 := uint32(p.To.Reg)
		v2 := uint32(p.From.Reg)
		v3 := uint32(p.Reg)
		v4 := uint32(p.GetFrom3().Reg)
		zVRRd(op, v1, v2, v3, m6, m5, v4, asm)

		op, m6, _ := vop(p.As)
		m5 := singleElementMask(p.As)
		v1 := uint32(p.To.Reg)
		v2 := uint32(p.From.Reg)
		v3 := uint32(p.Reg)
		v4 := uint32(p.GetFrom3().Reg)
		zVRRe(op, v1, v2, v3, m6, m5, v4, asm)

	case 122: // VRR-f从GRS不相交
		op, _, _ := vop(p.As)
		zVRRf(op, uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg), asm)

	case 123: // VPDI$m4，V2，V3，V1 
		op, _, _ := vop(p.As)
		m4 := c.regoff(&p.From)
		zVRRc(op, uint32(p.To.Reg), uint32(p.Reg), uint32(p.GetFrom3().Reg), 0, 0, uint32(m4), asm)
	}
}

func (c *ctxtz) vregoff(a *obj.Addr) int64 {
	c.instoffset = 0
	if a != nil {
		c.aclass(a)
	}
	return c.instoffset
}

func (c *ctxtz) regoff(a *obj.Addr) int32 {
	return int32(c.vregoff(a))
}

// 查找位移是否在12位
func isU12(displacement int32) bool {
	return displacement >= 0 && displacement < DISP12
}

// zopload12返回给定加载的带12位位移的RX op 
func (c *ctxtz) zopload12(a obj.As) (uint32, bool) {
	switch a {
	case AFMOVD:
		return op_LD, true
	case AFMOVS:
		return op_LE, true
	}
	return 0, false
}

// zopload返回给定加载的RXY op 
func (c *ctxtz) zopload(a obj.As) uint32 {
	switch a {
	// 定点加载
	case AMOVD:
		return op_LG
	case AMOVW:
		return op_LGF
	case AMOVWZ:
		return op_LLGF
	case AMOVH:
		return op_LGH
	case AMOVHZ:
		return op_LLGH
	case AMOVB:
		return op_LGB
	case AMOVBZ:
		return op_LLGC

	// 浮点加载
	case AFMOVD:
		return op_LDY
	case AFMOVS:
		return op_LEY

	// 字节反向加载
	case AMOVDBR:
		return op_LRVG
	case AMOVWBR:
		return op_LRV
	case AMOVHBR:
		return op_LRVH
	}

	c.ctxt.Diag("unknown store opcode %v", a)
	return 0
}

// ZOPTORE12返回RX op给定存储
func (c *ctxtz) zopstore12(a obj.As) (uint32, bool) {
	switch a {
	case AFMOVD:
		return op_STD, true
	case AFMOVS:
		return op_STE, true
	case AMOVW, AMOVWZ:
		return op_ST, true
	case AMOVH, AMOVHZ:
		return op_STH, true
	case AMOVB, AMOVBZ:
		return op_STC, true
	}
	return 0, false
}

// zopstore返回给定存储
func (c *ctxtz) zopstore(a obj.As) uint32 {
	switch a {
	// 定点存储
	case AMOVD:
		return op_STG
	case AMOVW, AMOVWZ:
		return op_STY
	case AMOVH, AMOVHZ:
		return op_STHY
	case AMOVB, AMOVBZ:
		return op_STCY

	// 浮点存储
	case AFMOVD:
		return op_STDY
	case AFMOVS:
		return op_STEY

	// 字节反转存储
	case AMOVDBR:
		return op_STRVG
	case AMOVWBR:
		return op_STRV
	case AMOVHBR:
		return op_STRVH
	}

	c.ctxt.Diag("unknown store opcode %v", a)
	return 0
}

// zoprre返回给定存储
func (c *ctxtz) zoprre(a obj.As) uint32 {
	switch a {
	case ACMP:
		return op_CGR
	case ACMPU:
		return op_CLGR
	case AFCMPO: // 有序
		return op_KDBR
	case AFCMPU: // 无序
		return op_CDBR
	case ACEBR:
		return op_CEBR
	}
	c.ctxt.Diag("unknown rre opcode %v", a)
	return 0
}

// zoprr返回给定a 
func (c *ctxtz) zoprr(a obj.As) uint32 {
	switch a {
	case ACMPW:
		return op_CR
	case ACMPWU:
		return op_CLR
	}
	c.ctxt.Diag("unknown rr opcode %v", a)
	return 0
}

// zopril返回给定a 
func (c *ctxtz) zopril(a obj.As) uint32 {
	switch a {
	case ACMP:
		return op_CGFI
	case ACMPU:
		return op_CLGFI
	case ACMPW:
		return op_CFI
	case ACMPWU:
		return op_CLFI
	}
	c.ctxt.Diag("unknown ril opcode %v", a)
	return 0
}

// z指令大小
const (
	sizeE    = 2
	sizeI    = 2
	sizeIE   = 4
	sizeMII  = 6
	sizeRI   = 4
	sizeRI1  = 4
	sizeRI2  = 4
	sizeRI3  = 4
	sizeRIE  = 6
	sizeRIE1 = 6
	sizeRIE2 = 6
	sizeRIE3 = 6
	sizeRIE4 = 6
	sizeRIE5 = 6
	sizeRIE6 = 6
	sizeRIL  = 6
	sizeRIL1 = 6
	sizeRIL2 = 6
	sizeRIL3 = 6
	sizeRIS  = 6
	sizeRR   = 2
	sizeRRD  = 4
	sizeRRE  = 4
	sizeRRF  = 4
	sizeRRF1 = 4
	sizeRRF2 = 4
	sizeRRF3 = 4
	sizeRRF4 = 4
	sizeRRF5 = 4
	sizeRRR  = 2
	sizeRRS  = 6
	sizeRS   = 4
	sizeRS1  = 4
	sizeRS2  = 4
	sizeRSI  = 4
	sizeRSL  = 6
	sizeRSY  = 6
	sizeRSY1 = 6
	sizeRSY2 = 6
	sizeRX   = 4
	sizeRX1  = 4
	sizeRX2  = 4
	sizeRXE  = 6
	sizeRXF  = 6
	sizeRXY  = 6
	sizeRXY1 = 6
	sizeRXY2 = 6
	sizeS    = 4
	sizeSI   = 4
	sizeSIL  = 6
	sizeSIY  = 6
	sizeSMI  = 6
	sizeSS   = 6
	sizeSS1  = 6
	sizeSS2  = 6
	sizeSS3  = 6
	sizeSS4  = 6
	sizeSS5  = 6
	sizeSS6  = 6
	sizeSSE  = 6
	sizeSSF  = 6
)

// 指令格式变化
type form int

const (
	_a form = iota
	_b
	_c
	_d
	_e
	_f
)

func zE(op uint32, asm *[]byte) {
	*asm = append(*asm, uint8(op>>8), uint8(op))
}

func zI(op, i1 uint32, asm *[]byte) {
	*asm = append(*asm, uint8(op>>8), uint8(i1))
}

func zMII(op, m1, ri2, ri3 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(m1)<<4)|uint8((ri2>>8)&0x0F),
		uint8(ri2),
		uint8(ri3>>16),
		uint8(ri3>>8),
		uint8(ri3))
}

func zRI(op, r1_m1, i2_ri2 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(r1_m1)<<4)|(uint8(op)&0x0F),
		uint8(i2_ri2>>8),
		uint8(i2_ri2))
}

// 指令格式的预期参数值。
// 
// 格式a1 a2 a3 a4 a5 a6 a7 
// ---------------------------------------
// a r1，0，0，i2，0，0，m3，0 
// e r1，r3，ri2，0，0，0 
// f r1，r2，0，i3，i4，0，i5 
// g r1，m3，i2，0，0 
func zRIE(f form, op, r1, r2_m3_r3, i2_ri4_ri2, i3, i4, m3, i2_i5 uint32, asm *[]byte) {
	*asm = append(*asm, uint8(op>>8), uint8(r1)<<4|uint8(r2_m3_r3&0x0F))

	switch f {
	default:
		*asm = append(*asm, uint8(i2_ri4_ri2>>8), uint8(i2_ri4_ri2))
	case _f:
		*asm = append(*asm, uint8(i3), uint8(i4))
	}

	switch f {
	case _a, _b:
		*asm = append(*asm, uint8(m3)<<4)
	default:
		*asm = append(*asm, uint8(i2_i5))
	}

	*asm = append(*asm, uint8(op))
}

func zRIL(f form, op, r1_m1, i2_ri2 uint32, asm *[]byte) {
	if f == _a || f == _b {
		r1_m1 = r1_m1 - obj.RBaseS390X // 这是一个寄存器基
	}
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(r1_m1)<<4)|(uint8(op)&0x0F),
		uint8(i2_ri2>>24),
		uint8(i2_ri2>>16),
		uint8(i2_ri2>>8),
		uint8(i2_ri2))
}

func zRIS(op, r1, m3, b4, d4, i2 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(r1)<<4)|uint8(m3&0x0F),
		(uint8(b4)<<4)|(uint8(d4>>8)&0x0F),
		uint8(d4),
		uint8(i2),
		uint8(op))
}

func zRR(op, r1, r2 uint32, asm *[]byte) {
	*asm = append(*asm, uint8(op>>8), (uint8(r1)<<4)|uint8(r2&0x0F))
}

func zRRD(op, r1, r3, r2 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		uint8(op),
		uint8(r1)<<4,
		(uint8(r3)<<4)|uint8(r2&0x0F))
}

func zRRE(op, r1, r2 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		uint8(op),
		0,
		(uint8(r1)<<4)|uint8(r2&0x0F))
}

func zRRF(op, r3_m3, m4, r1, r2 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		uint8(op),
		(uint8(r3_m3)<<4)|uint8(m4&0x0F),
		(uint8(r1)<<4)|uint8(r2&0x0F))
}

func zRRS(op, r1, r2, b4, d4, m3 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(r1)<<4)|uint8(r2&0x0F),
		(uint8(b4)<<4)|uint8((d4>>8)&0x0F),
		uint8(d4),
		uint8(m3)<<4,
		uint8(op))
}

func zRS(op, r1, r3_m3, b2, d2 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(r1)<<4)|uint8(r3_m3&0x0F),
		(uint8(b2)<<4)|uint8((d2>>8)&0x0F),
		uint8(d2))
}

func zRSI(op, r1, r3, ri2 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(r1)<<4)|uint8(r3&0x0F),
		uint8(ri2>>8),
		uint8(ri2))
}

func zRSL(op, l1, b2, d2 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		uint8(l1),
		(uint8(b2)<<4)|uint8((d2>>8)&0x0F),
		uint8(d2),
		uint8(op))
}

func zRSY(op, r1, r3_m3, b2, d2 uint32, asm *[]byte) {
	dl2 := uint16(d2) & 0x0FFF
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(r1)<<4)|uint8(r3_m3&0x0F),
		(uint8(b2)<<4)|(uint8(dl2>>8)&0x0F),
		uint8(dl2),
		uint8(d2>>12),
		uint8(op))
}

func zRX(op, r1_m1, x2, b2, d2 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(r1_m1)<<4)|uint8(x2&0x0F),
		(uint8(b2)<<4)|uint8((d2>>8)&0x0F),
		uint8(d2))
}

func zRXE(op, r1, x2, b2, d2, m3 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(r1)<<4)|uint8(x2&0x0F),
		(uint8(b2)<<4)|uint8((d2>>8)&0x0F),
		uint8(d2),
		uint8(m3)<<4,
		uint8(op))
}

func zRXF(op, r3, x2, b2, d2, m1 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(r3)<<4)|uint8(x2&0x0F),
		(uint8(b2)<<4)|uint8((d2>>8)&0x0F),
		uint8(d2),
		uint8(m1)<<4,
		uint8(op))
}

func zRXY(op, r1_m1, x2, b2, d2 uint32, asm *[]byte) {
	dl2 := uint16(d2) & 0x0FFF
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(r1_m1)<<4)|uint8(x2&0x0F),
		(uint8(b2)<<4)|(uint8(dl2>>8)&0x0F),
		uint8(dl2),
		uint8(d2>>12),
		uint8(op))
}

func zS(op, b2, d2 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		uint8(op),
		(uint8(b2)<<4)|uint8((d2>>8)&0x0F),
		uint8(d2))
}

func zSI(op, i2, b1, d1 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		uint8(i2),
		(uint8(b1)<<4)|uint8((d1>>8)&0x0F),
		uint8(d1))
}

func zSIL(op, b1, d1, i2 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		uint8(op),
		(uint8(b1)<<4)|uint8((d1>>8)&0x0F),
		uint8(d1),
		uint8(i2>>8),
		uint8(i2))
}

func zSIY(op, i2, b1, d1 uint32, asm *[]byte) {
	dl1 := uint16(d1) & 0x0FFF
	*asm = append(*asm,
		uint8(op>>8),
		uint8(i2),
		(uint8(b1)<<4)|(uint8(dl1>>8)&0x0F),
		uint8(dl1),
		uint8(d1>>12),
		uint8(op))
}

func zSMI(op, m1, b3, d3, ri2 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		uint8(m1)<<4,
		(uint8(b3)<<4)|uint8((d3>>8)&0x0F),
		uint8(d3),
		uint8(ri2>>8),
		uint8(ri2))
}

// 指令格式的预期参数值。
// 
// 格式a1 a2 a3 a4 a5 a6 
// ---------------------------------------
// a l1，0，b1，d1，b2，d2 
// b l1，l2，b1，d1，d1，b2，d2 
// c l1，i3，b1，d1，b2，d2 
// d r1，r3，b1，d1，b2，d2 
// f 0、l2、b1、d1、b2、d2 
func zSS(f form, op, l1_r1, l2_i3_r3, b1_b2, d1_d2, b2_b4, d2_d4 uint32, asm *[]byte) {
	*asm = append(*asm, uint8(op>>8))

	switch f {
	case _a:
		*asm = append(*asm, uint8(l1_r1))
	case _b, _c, _d, _e:
		*asm = append(*asm, (uint8(l1_r1)<<4)|uint8(l2_i3_r3&0x0F))
	case _f:
		*asm = append(*asm, uint8(l2_i3_r3))
	}

	*asm = append(*asm,
		(uint8(b1_b2)<<4)|uint8((d1_d2>>8)&0x0F),
		uint8(d1_d2),
		(uint8(b2_b4)<<4)|uint8((d2_d4>>8)&0x0F),
		uint8(d2_d4))
}

func zSSE(op, b1, d1, b2, d2 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		uint8(op),
		(uint8(b1)<<4)|uint8((d1>>8)&0x0F),
		uint8(d1),
		(uint8(b2)<<4)|uint8((d2>>8)&0x0F),
		uint8(d2))
}

func zSSF(op, r3, b1, d1, b2, d2 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(r3)<<4)|(uint8(op)&0x0F),
		(uint8(b1)<<4)|uint8((d1>>8)&0x0F),
		uint8(d1),
		(uint8(b2)<<4)|uint8((d2>>8)&0x0F),
		uint8(d2))
}

func rxb(va, vb, vc, vd uint32) uint8 {
	mask := uint8(0)
	if va >= REG_V16 && va <= REG_V31 {
		mask |= 0x8
	}
	if vb >= REG_V16 && vb <= REG_V31 {
		mask |= 0x4
	}
	if vc >= REG_V16 && vc <= REG_V31 {
		mask |= 0x2
	}
	if vd >= REG_V16 && vd <= REG_V31 {
		mask |= 0x1
	}
	return mask
}

func zVRX(op, v1, x2, b2, d2, m3 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(v1)<<4)|(uint8(x2)&0xf),
		(uint8(b2)<<4)|(uint8(d2>>8)&0xf),
		uint8(d2),
		(uint8(m3)<<4)|rxb(v1, 0, 0, 0),
		uint8(op))
}

func zVRV(op, v1, v2, b2, d2, m3 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(v1)<<4)|(uint8(v2)&0xf),
		(uint8(b2)<<4)|(uint8(d2>>8)&0xf),
		uint8(d2),
		(uint8(m3)<<4)|rxb(v1, v2, 0, 0),
		uint8(op))
}

func zVRS(op, v1, v3_r3, b2, d2, m4 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(v1)<<4)|(uint8(v3_r3)&0xf),
		(uint8(b2)<<4)|(uint8(d2>>8)&0xf),
		uint8(d2),
		(uint8(m4)<<4)|rxb(v1, v3_r3, 0, 0),
		uint8(op))
}

func zVRRa(op, v1, v2, m5, m4, m3 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(v1)<<4)|(uint8(v2)&0xf),
		0,
		(uint8(m5)<<4)|(uint8(m4)&0xf),
		(uint8(m3)<<4)|rxb(v1, v2, 0, 0),
		uint8(op))
}

func zVRRb(op, v1, v2, v3, m5, m4 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(v1)<<4)|(uint8(v2)&0xf),
		uint8(v3)<<4,
		uint8(m5)<<4,
		(uint8(m4)<<4)|rxb(v1, v2, v3, 0),
		uint8(op))
}

func zVRRc(op, v1, v2, v3, m6, m5, m4 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(v1)<<4)|(uint8(v2)&0xf),
		uint8(v3)<<4,
		(uint8(m6)<<4)|(uint8(m5)&0xf),
		(uint8(m4)<<4)|rxb(v1, v2, v3, 0),
		uint8(op))
}

func zVRRd(op, v1, v2, v3, m5, m6, v4 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(v1)<<4)|(uint8(v2)&0xf),
		(uint8(v3)<<4)|(uint8(m5)&0xf),
		uint8(m6)<<4,
		(uint8(v4)<<4)|rxb(v1, v2, v3, v4),
		uint8(op))
}

func zVRRe(op, v1, v2, v3, m6, m5, v4 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(v1)<<4)|(uint8(v2)&0xf),
		(uint8(v3)<<4)|(uint8(m6)&0xf),
		uint8(m5),
		(uint8(v4)<<4)|rxb(v1, v2, v3, v4),
		uint8(op))
}

func zVRRf(op, v1, r2, r3 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(v1)<<4)|(uint8(r2)&0xf),
		uint8(r3)<<4,
		0,
		rxb(v1, 0, 0, 0),
		uint8(op))
}

func zVRIa(op, v1, i2, m3 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		uint8(v1)<<4,
		uint8(i2>>8),
		uint8(i2),
		(uint8(m3)<<4)|rxb(v1, 0, 0, 0),
		uint8(op))
}

func zVRIb(op, v1, i2, i3, m4 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		uint8(v1)<<4,
		uint8(i2),
		uint8(i3),
		(uint8(m4)<<4)|rxb(v1, 0, 0, 0),
		uint8(op))
}

func zVRIc(op, v1, v3, i2, m4 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(v1)<<4)|(uint8(v3)&0xf),
		uint8(i2>>8),
		uint8(i2),
		(uint8(m4)<<4)|rxb(v1, v3, 0, 0),
		uint8(op))
}

func zVRId(op, v1, v2, v3, i4, m5 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(v1)<<4)|(uint8(v2)&0xf),
		uint8(v3)<<4,
		uint8(i4),
		(uint8(m5)<<4)|rxb(v1, v2, v3, 0),
		uint8(op))
}

func zVRIe(op, v1, v2, i3, m5, m4 uint32, asm *[]byte) {
	*asm = append(*asm,
		uint8(op>>8),
		(uint8(v1)<<4)|(uint8(v2)&0xf),
		uint8(i3>>4),
		(uint8(i3)<<4)|(uint8(m5)&0xf),
		(uint8(m4)<<4)|rxb(v1, v2, 0, 0),
		uint8(op))
}
